@libraz/libcantus 0.9.4 → 1.0.0

package/dist/index-G1uwGGWQ.d.ts

@@ -0,0 +1,643 @@
+import { g as NoteEvent } from './index-B9MNZboQ.js';
+import { e as StringFingering, c as Limb, I as InstrumentProfile } from './positional-Cptlj-xs.js';
+
+/**
+ * What makes a passage hard or impossible on an instrument.
+ *
+ * `noteOutOfRange` and `articulationUnavailable` belong to the first layer: the
+ * instrument has no position for what was written. `stringConflict`,
+ * `stretchTooWide`, `limbConflict` and `polyphonyExceeded` belong to the second:
+ * the notes exist but the arrangement cannot be held or struck. `tooFast`
+ * belongs to the third, the only one that depends on tempo.
+ *
+ * @category Core
+ */
+type PlayabilityIssueType = 'noteOutOfRange' | 'articulationUnavailable' | 'stringConflict' | 'stretchTooWide' | 'limbConflict' | 'polyphonyExceeded' | 'tooFast';
+/**
+ * Which playability layer an issue belongs to: 1 the note does not exist, 2 the
+ * arrangement does not hold together, 3 there is not enough time.
+ *
+ * @category Core
+ */
+type PlayabilityLayer = 1 | 2 | 3;
+/**
+ * One thing standing between a passage and a performance of it.
+ *
+ * @category Core
+ */
+type PlayabilityIssue = {
+    type: PlayabilityIssueType;
+    layer: PlayabilityLayer;
+    /** Indices into the analysed note array, ascending. */
+    notes: readonly number[];
+    /** Where the problem occurs, in quarter-note beats. */
+    startBeat: number;
+    /**
+     * True when practice cannot fix it. Layers 1 and 2 depend on the instrument
+     * alone, so they are impossible however skilled the player; only a layer-3
+     * issue is a matter of degree.
+     */
+    impossible: boolean;
+    message: string;
+};
+/**
+ * How one note is actually produced: the string and fret it is stopped at, or
+ * the limb that strikes it.
+ *
+ * This is reported for every note that has a position at all, whether or not
+ * the passage raises issues, so a caller can apply its own standard rather than
+ * take this module's.
+ *
+ * @category Core
+ */
+type NotePlacement = {
+    /** Index into the analysed note array. */
+    note: number;
+    /** String instruments: where the note is stopped. */
+    fingering?: StringFingering;
+    /** Percussion: which limb plays the stroke. */
+    limb?: Limb;
+};
+/**
+ * The verdict on a passage: how hard it is, what stands in the way, and how
+ * each note would be produced.
+ *
+ * @category Core
+ */
+type PlayabilityReport = {
+    /**
+     * Movement per unit time, mapped onto 1 (trivial) to 5 (at the limit).
+     * Without a tempo the passage is measured at 120 BPM, so the number stays
+     * comparable between passages; with one it rises as the tempo does.
+     */
+    difficulty: number;
+    issues: PlayabilityIssue[];
+    placements: NotePlacement[];
+};
+/**
+ * Judge whether a passage can be played on an instrument, and how hard it is.
+ *
+ * Inspection is deliberately separate from generation: this answers "can this
+ * be played" for a chart handed to a player or a practice tool, and never
+ * rewrites or rejects anything. The three layers are reported together but stay
+ * distinct — an out-of-range note or an impossible stretch is not the bottom of
+ * the difficulty scale but a different axis, since no amount of skill puts a
+ * note on an instrument that does not have it. Only the third layer consults
+ * `bpm`, so omitting the tempo reports what the instrument alone decides.
+ *
+ * @param notes The passage, in any order. Drum hits qualify as note events.
+ * @param profile The instrument to play it on.
+ * @param bpm Tempo in quarter-note beats per minute; enables the third layer.
+ * @returns Difficulty, the issues found, and each note's string/fret or limb.
+ *
+ * @example
+ * ```ts
+ * import { BASS_4_STRING, playability } from '@libraz/libcantus';
+ * const report = playability([{ pitch: 27, startBeat: 0, durationBeat: 1 }], BASS_4_STRING);
+ * report.issues[0]?.type; // 'noteOutOfRange'
+ * ```
+ * @category Core
+ */
+declare function playability(notes: readonly NoteEvent[], profile: InstrumentProfile, bpm?: number): PlayabilityReport;
+
+/**
+ * Note values: the written durations a score shows — a base value, its
+ * augmentation dots, and an optional tuplet ratio — and the conversion between
+ * them and the quarter-note beats the rest of the library measures in.
+ *
+ * The base values are named the American way (whole, half, quarter, eighth),
+ * matching the library's "quarter-note beat" convention and the vocabulary of
+ * the MIDI and DAW world this engine reads events from.
+ */
+/**
+ * A written base note value, from the whole note down to the sixty-fourth.
+ *
+ * Longer values (the breve and beyond) are written as tied notes; see
+ * {@link beatsToTiedDurations}.
+ *
+ * @category Rhythm & Meter
+ */
+type NoteValue = 'whole' | 'half' | 'quarter' | 'eighth' | 'sixteenth' | 'thirtySecond' | 'sixtyFourth';
+/**
+ * Every base note value, longest first.
+ *
+ * @category Rhythm & Meter
+ */
+declare const NOTE_VALUES: readonly NoteValue[];
+/**
+ * A tuplet ratio: `actual` written notes played in the time of `normal` ones —
+ * `{ actual: 3, normal: 2 }` for a triplet, `{ actual: 5, normal: 4 }` for a
+ * quintuplet.
+ *
+ * @category Rhythm & Meter
+ */
+type Tuplet = {
+    /** How many notes are written. */
+    actual: number;
+    /** How many of the same base value they occupy. */
+    normal: number;
+};
+/**
+ * A written duration: a base value, optional augmentation dots, and an optional
+ * tuplet ratio. Its length is `base * (2 - 2^-dots) * normal / actual`.
+ *
+ * @category Rhythm & Meter
+ */
+type DurationData = {
+    base: NoteValue;
+    /** Augmentation dots, 0 when absent; up to four are accepted. */
+    dots?: number;
+    tuplet?: Tuplet;
+};
+/**
+ * A duration as {@link beatsToDuration} spells it, with the dot count always
+ * stated.
+ *
+ * @category Rhythm & Meter
+ */
+type SpelledDuration = {
+    base: NoteValue;
+    dots: number;
+    tuplet?: Tuplet;
+};
+/**
+ * Length of a written duration in beats.
+ *
+ * @param duration The duration, or a bare base value as shorthand for an
+ *   undotted one.
+ * @param options `beatUnit` sets what one beat is; a quarter note by default,
+ *   so a dotted quarter reads as 1.5. Pass `{ base: 'quarter', dots: 1 }` to
+ *   count in the felt beats of a compound meter.
+ * @returns The length in beats.
+ * @throws If the base value is unknown, the dot count is not an integer in
+ *   0..4, or a tuplet side is not a positive integer.
+ * @example
+ * ```ts
+ * import { durationToBeats } from '@libraz/libcantus';
+ * durationToBeats('quarter'); // 1
+ * durationToBeats({ base: 'quarter', dots: 1 }); // 1.5
+ * durationToBeats({ base: 'eighth', tuplet: { actual: 3, normal: 2 } }); // 1/3
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function durationToBeats(duration: NoteValue | DurationData, options?: {
+    beatUnit?: NoteValue | DurationData;
+}): number;
+/**
+ * Spell a length in beats as the note value a score would show.
+ *
+ * The spelling is the conventional one, not merely an arithmetically valid one:
+ * 1.5 beats is a dotted quarter rather than a quarter tied to an eighth, and a
+ * third of a beat is an eighth triplet rather than a twenty-fourth note. Plain
+ * values are preferred to dotted ones and both to tuplets, and within the
+ * tuplets triplets come before quintuplets and septuplets.
+ *
+ * Lengths are matched within 1e-6 beats, so a rounded decimal such as 0.3333333
+ * still reads as a triplet.
+ *
+ * @param beats The length in beats.
+ * @param options `beatUnit` sets what one beat is; a quarter note by default.
+ * @returns The base value, its dot count, and its tuplet when it has one.
+ * @throws If `beats` is not positive, or — as a `NoSolutionError` — if no single
+ *   note value spells it, as for 5 beats in 4/4. Use
+ *   {@link beatsToTiedDurations} for those.
+ * @example
+ * ```ts
+ * import { beatsToDuration } from '@libraz/libcantus';
+ * beatsToDuration(1.5); // { base: 'quarter', dots: 1 }
+ * beatsToDuration(1 / 3); // { base: 'eighth', dots: 0, tuplet: { actual: 3, normal: 2 } }
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function beatsToDuration(beats: number, options?: {
+    beatUnit?: NoteValue | DurationData;
+}): SpelledDuration;
+/**
+ * Spell a length in beats as a chain of tied note values.
+ *
+ * A length with a single spelling comes back as a one-element chain. Anything
+ * else is broken into undotted values, longest first, and a value immediately
+ * followed by its own half is then written as a dot instead: 5 beats reads as a
+ * whole note tied to a quarter, and 1.9375 beats as a double-dotted quarter tied
+ * to a dotted thirty-second. The chain knows nothing of barlines or beat
+ * grouping — an engraver splits further at those — and it uses no tuplets, so a
+ * length off the plain grid and with no single spelling has no chain either.
+ *
+ * @param beats The length in beats.
+ * @param options `beatUnit` sets what one beat is; a quarter note by default.
+ * @returns The tied durations, longest first, summing to `beats`.
+ * @throws If `beats` is not positive, if the chain would exceed the generation
+ *   budget, or — as a `NoSolutionError` — if no chain of plain and dotted values
+ *   sums to it.
+ * @example
+ * ```ts
+ * import { beatsToTiedDurations } from '@libraz/libcantus';
+ * beatsToTiedDurations(5); // [{ base: 'whole', dots: 0 }, { base: 'quarter', dots: 0 }]
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function beatsToTiedDurations(beats: number, options?: {
+    beatUnit?: NoteValue | DurationData;
+}): SpelledDuration[];
+
+/**
+ * A validated note retaining its position in the caller's original array.
+ *
+ * @category Core
+ */
+type IndexedNoteEvent = {
+    note: Readonly<NoteEvent>;
+    originalIndex: number;
+    endBeat: number;
+};
+/**
+ * Which note wins when several sound from the same onset.
+ *
+ * `'highest'` and `'lowest'` name a voice, so the answer does not depend on the
+ * order the caller happened to store the chord in; `'last'` takes the one
+ * latest in the input array.
+ *
+ * @category Core
+ */
+type OnsetTieBreak = 'highest' | 'lowest' | 'last';
+/**
+ * Binary-searchable, stable-sorted index over note onsets and active spans.
+ *
+ * @category Core
+ */
+type NoteEventIndex = {
+    notes: readonly IndexedNoteEvent[];
+    /**
+     * Latest-onset note sounding at `beat`. Simultaneous onsets are resolved by
+     * the index's {@link OnsetTieBreak}.
+     *
+     * @throws If `beat` is not finite.
+     */
+    at: (beat: number) => IndexedNoteEvent | undefined;
+    /**
+     * Whether one or more sounding notes attack at `beat`.
+     *
+     * @throws If `beat` is not finite.
+     */
+    attacksAt: (beat: number) => boolean;
+    /**
+     * Unique sounding-note attack beats strictly inside `(startBeat, endBeat)`.
+     *
+     * @throws If either bound is not finite.
+     */
+    onsetsBetween: (startBeat: number, endBeat: number) => number[];
+};
+/**
+ * How an index reads the events it is built from.
+ *
+ * @category Core
+ */
+type NoteEventIndexOptions = {
+    allowNonPositiveDuration?: boolean;
+    tieBreak?: OnsetTieBreak;
+    budget?: number;
+    /** What the events are, for the validation error message. */
+    name?: string;
+};
+/**
+ * Validate and stable-sort note events once, then expose logarithmic onset and
+ * active-note lookups. Non-positive-duration notes may be retained for callers
+ * that intentionally filter them later, but never count as sounding.
+ *
+ * @category Core
+ */
+declare function createNoteEventIndex(events: readonly NoteEvent[], options?: NoteEventIndexOptions): NoteEventIndex;
+
+/**
+ * Tempo and time conversion: beats to wall-clock seconds across tempo changes,
+ * and beats to MIDI ticks.
+ *
+ * Positions are measured in quarter-note beats, matching the rest of the
+ * library's beat convention. A {@link TempoMap} is piecewise constant: each
+ * entry sets the tempo from its beat onwards, so the elapsed time over a span is
+ * the sum of the segments it crosses rather than the tempo at either end.
+ */
+/**
+ * A tempo change: the beat it takes effect on, and the tempo it sets.
+ *
+ * The tempo holds until the next entry, so a map of one entry is a constant
+ * tempo for the whole timeline.
+ *
+ * @category Rhythm & Meter
+ */
+type TempoEvent = {
+    /** Onset in quarter-note beats, absolute from the start of the timeline. */
+    readonly startBeat: number;
+    /** Quarter-note beats per minute from `startBeat` onwards. */
+    readonly bpm: number;
+};
+/**
+ * A tempo track: {@link TempoEvent}s sorted by `startBeat`, strictly ascending.
+ *
+ * The first entry is the time origin — {@link beatsToSeconds} returns 0 for its
+ * `startBeat` — and its tempo also governs the beats before it, which is where
+ * a pickup sounds. A map cannot say anything else about that stretch, and a
+ * piece is played into its first downbeat at the tempo it starts in, so elapsed
+ * time there is negative rather than an error.
+ *
+ * @category Rhythm & Meter
+ */
+type TempoMap = readonly TempoEvent[];
+/**
+ * Wall-clock seconds from the start of a tempo map to a beat.
+ *
+ * The result integrates every tempo segment the span crosses; it is not the
+ * tempo in effect at `beat` applied to the whole span.
+ *
+ * A beat before the map's first event reports negative elapsed time, at the
+ * opening tempo: a pickup sounds before the downbeat, and asking when it sounds
+ * is a fair question.
+ *
+ * @param beat Position in quarter-note beats.
+ * @param map The tempo map; its first event is the time origin.
+ * @returns Elapsed seconds, 0 at the map's first event and negative before it.
+ * @throws If the map is empty, unsorted, or carries a non-positive tempo.
+ * @example
+ * ```ts
+ * import { beatsToSeconds } from '@libraz/libcantus';
+ * const map = [{ startBeat: 0, bpm: 120 }, { startBeat: 4, bpm: 60 }];
+ * beatsToSeconds(8, map); // 6 = 4 beats at 120 + 4 beats at 60
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function beatsToSeconds(beat: number, map: TempoMap): number;
+/**
+ * The beat reached after a number of seconds — the inverse of
+ * {@link beatsToSeconds}.
+ *
+ * @param seconds Elapsed seconds from the map's first event; negative for a
+ *   position before it, such as a pickup.
+ * @param map The tempo map.
+ * @returns The position in quarter-note beats.
+ * @throws If the map is malformed or `seconds` is not finite.
+ * @example
+ * ```ts
+ * import { secondsToBeats } from '@libraz/libcantus';
+ * const map = [{ startBeat: 0, bpm: 120 }, { startBeat: 4, bpm: 60 }];
+ * secondsToBeats(6, map); // 8
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function secondsToBeats(seconds: number, map: TempoMap): number;
+/**
+ * Duration in seconds of a span of beats.
+ *
+ * Equal to the difference of two {@link beatsToSeconds} calls — the integral is
+ * additive, so that reading is exact — but integrated over the span directly, so
+ * a short note late in a long piece does not lose precision to the subtraction
+ * of two large elapsed times.
+ *
+ * @param startBeat Where the span begins, in quarter-note beats; a pickup
+ *   starts before the map's first event and is measured like any other span.
+ * @param lengthBeats How long the span lasts, in quarter-note beats.
+ * @param map The tempo map.
+ * @returns The span's duration in seconds, never negative.
+ * @throws If the map is malformed or the length is negative.
+ * @example
+ * ```ts
+ * import { durationToSeconds } from '@libraz/libcantus';
+ * const map = [{ startBeat: 0, bpm: 120 }, { startBeat: 4, bpm: 60 }];
+ * durationToSeconds(2, 4, map); // 3 = 2 beats at 120 + 2 beats at 60
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function durationToSeconds(startBeat: number, lengthBeats: number, map: TempoMap): number;
+/**
+ * The tempo in effect at a beat.
+ *
+ * A beat before the first event reads the opening tempo, which is the tempo a
+ * pickup is played at.
+ *
+ * @param beat Position in quarter-note beats.
+ * @param map The tempo map.
+ * @returns Quarter-note beats per minute.
+ * @throws If the map is malformed.
+ * @example
+ * ```ts
+ * import { tempoAt } from '@libraz/libcantus';
+ * tempoAt(5, [{ startBeat: 0, bpm: 120 }, { startBeat: 4, bpm: 60 }]); // 60
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function tempoAt(beat: number, map: TempoMap): number;
+/**
+ * Convert quarter-note beats to MIDI ticks.
+ *
+ * Ticks are whole units of a sequencer's grid, so the result is rounded to the
+ * nearest tick; a beat that is not on the grid is not representable and comes
+ * back quantized.
+ *
+ * A position before the first downbeat is a negative tick count, which is how a
+ * pickup crosses the MIDI boundary and comes back.
+ *
+ * @param beat Position or length in quarter-note beats.
+ * @param ppq Pulses (ticks) per quarter note, e.g. 96, 480, or 960.
+ * @returns The whole tick count.
+ * @throws If `beat` is not finite or `ppq` is not a positive integer.
+ * @example
+ * ```ts
+ * import { beatsToTicks } from '@libraz/libcantus';
+ * beatsToTicks(1.5, 480); // 720
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function beatsToTicks(beat: number, ppq: number): number;
+/**
+ * Convert MIDI ticks to quarter-note beats.
+ *
+ * @param ticks Whole tick count, negative before the first downbeat.
+ * @param ppq Pulses (ticks) per quarter note, e.g. 96, 480, or 960.
+ * @returns The position or length in quarter-note beats.
+ * @throws If `ticks` is not an integer or `ppq` is not a positive integer.
+ * @example
+ * ```ts
+ * import { ticksToBeats } from '@libraz/libcantus';
+ * ticksToBeats(720, 480); // 1.5
+ * ```
+ * @category Rhythm & Meter
+ */
+declare function ticksToBeats(ticks: number, ppq: number): number;
+
+/**
+ * Tuning and microtonality: frequency conversion, cents, arbitrary equal
+ * temperaments (EDO), and just-intonation ratios.
+ *
+ * The rest of the library reasons in twelve-tone pitch classes, which is a
+ * deliberate scope choice for tonal theory. This module is the escape hatch for
+ * anyone who needs actual frequencies, cents, non-12 equal temperaments, or the
+ * acoustic (just) tuning behind the tempered intervals.
+ */
+/**
+ * An equal-tempered tuning: a reference pitch and a number of equal divisions of
+ * the octave. With `divisions === 12` a step index is an ordinary MIDI number.
+ *
+ * @category Pitch & Intervals
+ */
+type TuningTable = {
+    /** Step index (MIDI number when `divisions` is 12) whose frequency is `refFreq`. */
+    readonly refStep: number;
+    /** Frequency in Hz of `refStep`. */
+    readonly refFreq: number;
+    /** Equal divisions of the octave (12 standard; e.g. 19 or 31 for microtonal). */
+    readonly divisions: number;
+};
+/**
+ * Standard twelve-tone equal temperament, A4 (MIDI 69) = 440 Hz.
+ *
+ * @category Pitch & Intervals
+ */
+declare const TWELVE_TET: TuningTable;
+/**
+ * Build an equal temperament with `n` divisions of the octave.
+ *
+ * @param n Divisions of the octave (e.g. 19, 24, 31).
+ * @param refFreq Reference frequency in Hz (default 440).
+ * @param refStep Step index of the reference (default 69).
+ * @returns The tuning.
+ * @example
+ * ```ts
+ * import { edo, frequencyOf } from '@libraz/libcantus';
+ * const et19 = edo(19); // { refStep: 69, refFreq: 440, divisions: 19 }
+ * frequencyOf(70, et19); // one 19-EDO step above A4
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function edo(n: number, refFreq?: number, refStep?: number): TuningTable;
+/**
+ * Frequency in Hz of a step index under a tuning.
+ *
+ * @param step Step index (a MIDI number under 12-EDO).
+ * @param tuning The tuning (default 12-TET).
+ * @returns The frequency in Hz.
+ * @example
+ * ```ts
+ * import { frequencyOf } from '@libraz/libcantus';
+ * frequencyOf(69); // 440 (A4 in 12-TET)
+ * frequencyOf(60); // middle C in Hz
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function frequencyOf(step: number, tuning?: TuningTable): number;
+/**
+ * Nearest step index to a frequency under a tuning (the inverse of
+ * {@link frequencyOf}, rounded).
+ *
+ * @param freq Frequency in Hz.
+ * @param tuning The tuning (default 12-TET).
+ * @returns The nearest step index.
+ * @category Pitch & Intervals
+ */
+declare function nearestStep(freq: number, tuning?: TuningTable): number;
+/**
+ * Step index of a frequency under a tuning, unrounded.
+ *
+ * The exact inverse of {@link frequencyOf}. {@link nearestStep} rounds it,
+ * which discards how far off the pitch actually is — the figure a tuner
+ * display, a pitch-bend amount, or an intonation check is built on.
+ *
+ * @param freq Frequency in Hz.
+ * @param tuning The tuning (default 12-TET).
+ * @returns The fractional step index.
+ * @example
+ * ```ts
+ * import { stepOf } from '@libraz/libcantus';
+ * stepOf(442); // slightly above 69, the step for A440
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function stepOf(freq: number, tuning?: TuningTable): number;
+/**
+ * How far a frequency sits from its nearest step, in cents.
+ *
+ * Positive means sharp of the step, negative flat.
+ *
+ * @param freq Frequency in Hz.
+ * @param tuning The tuning (default 12-TET).
+ * @returns The signed deviation in cents.
+ * @example
+ * ```ts
+ * import { centsFromNearestStep } from '@libraz/libcantus';
+ * Math.round(centsFromNearestStep(442)); // 8
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function centsFromNearestStep(freq: number, tuning?: TuningTable): number;
+/**
+ * Steps spanned by an interval in cents, unrounded — the inverse of
+ * {@link centsOfSteps}.
+ *
+ * @param cents The interval in cents.
+ * @param tuning The tuning (default 12-TET).
+ * @returns The fractional step count.
+ * @category Pitch & Intervals
+ */
+declare function stepsOfCents(cents: number, tuning?: TuningTable): number;
+/**
+ * The frequency ratio an interval in cents spans — the inverse of
+ * {@link ratioToCents}.
+ *
+ * Multiply a frequency by this to move it by that many cents, which is how a
+ * cents offset (a pitch-bend spec, a tuning table entry) is applied.
+ *
+ * @param cents The interval in cents.
+ * @returns The frequency ratio.
+ * @example
+ * ```ts
+ * import { centsToRatio } from '@libraz/libcantus';
+ * 440 * centsToRatio(14); // A440 raised by 14 cents
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function centsToRatio(cents: number): number;
+/**
+ * Interval in cents between two frequencies.
+ *
+ * @param a Lower/first frequency in Hz.
+ * @param b Upper/second frequency in Hz.
+ * @returns Cents from `a` to `b` (negative if `b` is lower).
+ * @category Pitch & Intervals
+ */
+declare function centsBetweenFreq(a: number, b: number): number;
+/**
+ * Cents spanned by a number of equal-temperament steps.
+ *
+ * @param steps Number of steps.
+ * @param tuning The tuning (default 12-TET).
+ * @returns The cents.
+ * @category Pitch & Intervals
+ */
+declare function centsOfSteps(steps: number, tuning?: TuningTable): number;
+/**
+ * Cents of a frequency ratio, e.g. `ratioToCents(3, 2)` ≈ 701.955 for the just
+ * perfect fifth.
+ *
+ * @param numerator Ratio numerator.
+ * @param denominator Ratio denominator.
+ * @returns The interval in cents.
+ * @category Pitch & Intervals
+ */
+declare function ratioToCents(numerator: number, denominator: number): number;
+/**
+ * Five-limit just-intonation ratios for the twelve interval classes above a
+ * unison, indexed by semitone class (0..12).
+ *
+ * @category Pitch & Intervals
+ */
+declare const JUST_RATIOS: Readonly<Record<number, readonly [number, number]>>;
+/**
+ * Cents by which a five-limit just interval departs from its 12-TET tempering
+ * (positive means the just interval is wider).
+ *
+ * @param semitoneClass Semitone class in [0, 12].
+ * @returns The deviation in cents.
+ * @throws If `semitoneClass` is not an integer in [0, 12].
+ * @category Pitch & Intervals
+ */
+declare function justDeviationCents(semitoneClass: number): number;
+
+export { playability as A, ratioToCents as B, secondsToBeats as C, type DurationData as D, stepOf as E, stepsOfCents as F, tempoAt as G, ticksToBeats as H, type IndexedNoteEvent as I, JUST_RATIOS as J, NOTE_VALUES as N, type OnsetTieBreak as O, type PlayabilityIssue as P, type SpelledDuration as S, TWELVE_TET as T, type NoteEventIndex as a, type NoteEventIndexOptions as b, type NotePlacement as c, type NoteValue as d, type PlayabilityIssueType as e, type PlayabilityLayer as f, type PlayabilityReport as g, type TempoEvent as h, type TempoMap as i, type TuningTable as j, type Tuplet as k, beatsToDuration as l, beatsToSeconds as m, beatsToTicks as n, beatsToTiedDurations as o, centsBetweenFreq as p, centsFromNearestStep as q, centsOfSteps as r, centsToRatio as s, createNoteEventIndex as t, durationToBeats as u, durationToSeconds as v, edo as w, frequencyOf as x, justDeviationCents as y, nearestStep as z };