@libraz/libcantus 0.9.4 → 1.0.0

package/dist/index-OG65ocOr.d.ts

@@ -1,272 +0,0 @@
-/**
- * Pitch spelling: letter-name notes, enharmonic-aware conversion, and spelled
- * intervals.
- *
- * The rest of the library works in pitch classes (0..11), which cannot tell a
- * G# from an Ab or an augmented fourth from a diminished fifth. This module adds
- * an explicit spelling layer — a note is a diatonic letter plus a chromatic
- * alteration — so interval quality (P/M/m/A/d) and enharmonic identity are
- * preserved.
- */
-/**
- * A spelled note: a diatonic letter, a chromatic alteration, and an optional
- * octave.
- *
- * - `letter` is 0..6 for C..B.
- * - `alter` is the number of semitones of alteration: -2 double-flat, -1 flat,
- *   0 natural, +1 sharp, +2 double-sharp.
- * - `octave` follows scientific pitch notation (middle C = C4 = MIDI 60). When
- *   absent, the note denotes a bare pitch class.
- *
- * @category Pitch & Intervals
- */
-type Note = {
-    letter: number;
-    alter: number;
-    octave?: number;
-};
-/**
- * The quality label of a spelled interval: perfect, major, minor, or one or
- * more augmentations or diminutions.
- *
- * This names how an interval is *spelled*. It is a different notion from
- * {@link ConsonanceClass}, which classifies how an interval *sounds* against
- * another voice.
- *
- * @see {@link ConsonanceClass}
- * @category Pitch & Intervals
- */
-type IntervalQualityLabel = 'P' | 'M' | 'm' | `A${string}` | `d${string}`;
-/**
- * A spelled interval: a diatonic number, a quality label, and its semitone span.
- *
- * @category Pitch & Intervals
- */
-type SpelledInterval = {
-    /** Diatonic size: 1 = unison, 2 = second, ... 8 = octave, and beyond. */
-    number: number;
-    /** Quality label: 'P', 'M', 'm', or repeated 'A'/'d' for (multiply) aug/dim. */
-    quality: IntervalQualityLabel;
-    /** Signed semitone distance from the first note to the second. */
-    semitones: number;
-};
-/**
- * Reduce a MIDI pitch, a bare pitch class, or any signed offset to a pitch
- * class in [0, 11].
- *
- * This is the library's single definition of pitch-class arithmetic: every
- * layer routes through it so a fractional pitch reduces the same way
- * everywhere. A non-integral input is rounded to the nearest semitone first, so
- * a microtonal 60.6 reads as C# rather than C.
- *
- * @param value A MIDI pitch, pitch class, or signed semitone offset.
- * @returns The pitch class in [0, 11].
- * @example
- * ```ts
- * import { pitchClassOf } from '@libraz/libcantus';
- * pitchClassOf(61); // 1
- * pitchClassOf(-1); // 11
- * pitchClassOf(60.6); // 1
- * ```
- * @category Pitch & Intervals
- */
-declare function pitchClassOf(value: number): number;
-/**
- * Reduce a letter number or letter offset to a diatonic letter in [0, 6]
- * (0 = C .. 6 = B).
- *
- * @param value A letter number or signed letter offset.
- * @returns The diatonic letter in [0, 6].
- * @category Pitch & Intervals
- */
-declare function diatonicLetterOf(value: number): number;
-/**
- * The pitch class of a diatonic letter with no accidental (C = 0, D = 2, ...).
- *
- * @param letter A letter number or signed letter offset; reduced to [0, 6].
- * @returns The natural pitch class of that letter.
- * @category Pitch & Intervals
- */
-declare function naturalPitchClassOf(letter: number): number;
-/**
- * Parse scientific pitch notation into a {@link Note}.
- *
- * Accepts a letter (case-insensitive) followed by any number of same-direction
- * accidentals and an optional octave, e.g. `"C"`, `"C#4"`, `"Bb"`, `"F##3"`,
- * `"Ebb2"`. Both `#` and `x` (double-sharp) are accepted for sharps; `b` for
- * flats. Mixing sharps and flats (e.g. `"C#b"`) is rejected.
- *
- * @param text The note text.
- * @returns The parsed note.
- * @throws If the text is not a valid note.
- * @example
- * ```ts
- * import { parseNote, noteToMidi } from '@libraz/libcantus';
- * const n = parseNote('C#4');
- * noteToMidi(n); // 61
- * ```
- * @category Pitch & Intervals
- */
-declare function parseNote(text: string): Note;
-/**
- * Render a {@link Note} as scientific pitch notation.
- *
- * @param note The note to format.
- * @returns The note text, including the octave when present.
- * @example
- * ```ts
- * import { formatNote, parseNote } from '@libraz/libcantus';
- * formatNote(parseNote('C#4')); // 'C#4'
- * ```
- * @category Pitch & Intervals
- */
-declare function formatNote(note: Note): string;
-/**
- * Pitch class (0..11) of a note, ignoring octave.
- *
- * @param note The note.
- * @returns The pitch class.
- * @example
- * ```ts
- * import { noteToPitchClass, parseNote } from '@libraz/libcantus';
- * noteToPitchClass(parseNote('Db')); // 1
- * ```
- * @category Pitch & Intervals
- */
-declare function noteToPitchClass(note: Note): number;
-/**
- * MIDI number of a note (middle C = C4 = 60).
- *
- * @param note The note; must carry an octave.
- * @returns The MIDI number.
- * @throws If the note has no octave.
- * @example
- * ```ts
- * import { noteToMidi, parseNote } from '@libraz/libcantus';
- * noteToMidi(parseNote('A4')); // 69
- * ```
- * @category Pitch & Intervals
- */
-declare function noteToMidi(note: Note): number;
-/**
- * Name a MIDI number as a {@link Note}, choosing sharp or flat spelling.
- *
- * The input is rounded to the nearest integer but is not clamped to the MIDI
- * range 0..127: out-of-range values extrapolate linearly (e.g. `-1` -> `B-2`,
- * `128` -> `G#9`) and remain an exact inverse of {@link noteToMidi}.
- *
- * @param midi The MIDI number.
- * @param spelling Whether to prefer sharps or flats for black keys.
- * @returns The spelled note, with octave.
- * @example
- * ```ts
- * import { midiToNote, formatNote } from '@libraz/libcantus';
- * formatNote(midiToNote(61)); // 'C#4'
- * formatNote(midiToNote(61, 'flat')); // 'Db4'
- * ```
- * @category Pitch & Intervals
- */
-declare function midiToNote(midi: number, spelling?: 'sharp' | 'flat'): Note;
-/**
- * Transpose a note by a signed number of semitones, keeping its spelling.
- *
- * The letter moves by the diatonic distance of the conventional interval for
- * that many semitones and the accidental is recomputed for the new letter, so
- * enharmonic identity survives: `Ab4` up a major second is `Bb4`, not `A#4`, and
- * the operation is an exact inverse of itself. An octave-less note stays
- * octave-less.
- *
- * A bare semitone count cannot distinguish an augmented fourth from a diminished
- * fifth; pass `spelling` to override the letter distance when the enharmonic
- * choice matters.
- *
- * @param note The note to transpose.
- * @param semitones The signed semitone offset.
- * @param opts `spelling` forces the result onto the sharp or flat side instead
- *   of following the source note's letter.
- * @returns The transposed note.
- * @example
- * ```ts
- * import { transposeNote, formatNote, parseNote } from '@libraz/libcantus';
- * formatNote(transposeNote(parseNote('Ab4'), 2)); // 'Bb4'
- * formatNote(transposeNote(parseNote('Ab4'), 2, { spelling: 'sharp' })); // 'A#4'
- * ```
- * @category Pitch & Intervals
- */
-declare function transposeNote(note: Note, semitones: number, opts?: {
-    spelling?: 'sharp' | 'flat';
-}): Note;
-/**
- * The semitone span of the interval named by a diatonic number and a quality.
- *
- * The inverse of the quality derivation in {@link spelledInterval}: it turns a
- * name back into a distance, which is what transposing by a named interval or
- * parsing one from text needs.
- *
- * @param numberValue Diatonic size: 1 = unison, 2 = second, ... 8 = octave.
- * @param quality Quality label: `'P'`, `'M'`, `'m'`, or repeated `'A'`/`'d'`.
- * @returns The unsigned semitone span.
- * @throws If the quality cannot apply to the number, such as a major fifth.
- * @example
- * ```ts
- * import { intervalSemitones } from '@libraz/libcantus';
- * intervalSemitones(5, 'P'); // 7
- * ```
- * @category Pitch & Intervals
- */
-declare function intervalSemitones(numberValue: number, quality: IntervalQualityLabel): number;
-/**
- * Parse an interval name such as `'P5'`, `'m3'`, or `'AA4'`.
- *
- * @param name The interval name: a quality label followed by a diatonic number.
- * @returns The spelled interval, with an ascending (positive) span.
- * @throws If the name is not a quality label followed by a number, or the two
- *   cannot describe the same interval.
- * @example
- * ```ts
- * import { parseInterval } from '@libraz/libcantus';
- * parseInterval('m3'); // { number: 3, quality: 'm', semitones: 3 }
- * ```
- * @category Pitch & Intervals
- */
-declare function parseInterval(name: string): SpelledInterval;
-/**
- * Transpose a note by a spelled interval, keeping the spelling the interval
- * names.
- *
- * Unlike {@link transposeNote}, which picks a letter from the semitone count,
- * the diatonic number decides the letter here: transposing C by an augmented
- * second gives D#, not Eb.
- *
- * @param note The note to transpose.
- * @param interval The interval to apply; a negative span transposes downward.
- * @returns The transposed note, octave-less if the source was.
- * @example
- * ```ts
- * import { formatNote, parseInterval, parseNote, transposeByInterval } from '@libraz/libcantus';
- * formatNote(transposeByInterval(parseNote('C4'), parseInterval('A2'))); // 'D#4'
- * ```
- * @category Pitch & Intervals
- */
-declare function transposeByInterval(note: Note, interval: SpelledInterval): Note;
-/**
- * The spelled interval from one note to another.
- *
- * When both notes carry octaves, the interval reflects their full signed
- * distance (so `C4 -> C5` is a perfect octave). When either lacks an octave the
- * interval is measured within a single ascending octave from `a` to `b`.
- *
- * @param a The lower/first note.
- * @param b The upper/second note.
- * @returns The diatonic number, quality, and semitone span.
- * @example
- * ```ts
- * import { spelledInterval, parseNote } from '@libraz/libcantus';
- * spelledInterval(parseNote('C4'), parseNote('G4'));
- * // { number: 5, quality: 'P', semitones: 7 }
- * ```
- * @category Pitch & Intervals
- */
-declare function spelledInterval(a: Note, b: Note): SpelledInterval;
-
-export { type IntervalQualityLabel as I, type Note as N, type SpelledInterval as S, noteToMidi as a, noteToPitchClass as b, parseNote as c, diatonicLetterOf as d, pitchClassOf as e, formatNote as f, transposeNote as g, intervalSemitones as i, midiToNote as m, naturalPitchClassOf as n, parseInterval as p, spelledInterval as s, transposeByInterval as t };

package/dist/index-tJhkmQgE.d.cts

@@ -1,143 +0,0 @@
-import { K as KeyScale } from './types-BN6_Q9Kl.cjs';
-import { C as Chord } from './index-y_ak9_Hi.cjs';
-
-/**
- * Severity policy: `strict` counterpoint vs. lenient `pop` voice-leading.
- *
- * @category Arrangement & Analysis
- */
-type SafetyProfile = 'strict' | 'pop';
-/**
- * Overall placeability verdict for a candidate pitch.
- *
- * @category Arrangement & Analysis
- */
-declare enum NoteSafety {
-    Safe = 0,
-    Warning = 1,
-    Dissonant = 2
-}
-/**
- * Bit flags describing why a pitch received its verdict.
- *
- * @category Arrangement & Analysis
- */
-declare enum ReasonFlag {
-    ChordTone = 1,
-    Tension = 2,
-    AvoidNote = 4,
-    ScaleTone = 8,
-    NonScale = 16,
-    OutOfRange = 32,
-    Tritone = 64,
-    LargeLeap = 128,
-    MinorSecond = 256,
-    MajorSeventh = 512,
-    VerticalDissonance = 1024,
-    ParallelPerfect = 2048,
-    HiddenParallel = 4096,
-    VoiceCrossing = 8192,
-    Suspension = 16384,
-    NeedsResolution = 32768
-}
-/**
- * A neighbouring voice's current and previous pitch.
- *
- * @category Arrangement & Analysis
- */
-type VoiceSnapshot = {
-    pitch: number;
-    prevPitch?: number;
-};
-/**
- * Everything needed to evaluate one candidate pitch.
- *
- * @category Arrangement & Analysis
- */
-type SafetyQuery = {
-    profile: SafetyProfile;
-    candidatePitch: number;
-    prevPitch?: number;
-    chord: Chord | null;
-    key: KeyScale;
-    otherVoices: VoiceSnapshot[];
-    strongBeat: boolean;
-    vocalLow?: number;
-    vocalHigh?: number;
-};
-/**
- * The verdict, reason flags, and optional resolution guidance.
- *
- * @category Arrangement & Analysis
- */
-type SafetyResult = {
-    safety: NoteSafety;
-    reasons: number;
-    resolveTo?: number;
-    suggestions?: number[];
-    rationale?: string;
-};
-/**
- * Evaluate the safety of placing a candidate pitch in a voice.
- *
- * Reasons are merged from harmonic context (chord tone / tension / avoid / scale)
- * and counterpoint (vertical dissonance, parallels, voice crossing). The `strict`
- * profile treats avoid notes and parallels as dissonant; `pop` treats them as
- * warnings. The final verdict is the worst severity among the reasons.
- *
- * @param q The candidate and its harmonic/voice-leading context.
- * @returns The verdict, reason bitmask, and optional resolution guidance.
- * @example
- * ```ts
- * import { evaluateSafety, makeChord, majorKey, NoteSafety } from '@libraz/libcantus';
- * const result = evaluateSafety({
- *   profile: 'pop',
- *   candidatePitch: 60, // C over a C major chord
- *   chord: makeChord(0, 'maj'),
- *   key: majorKey(0),
- *   otherVoices: [],
- *   strongBeat: true,
- * });
- * result.safety === NoteSafety.Safe; // true — C is a chord tone
- * ```
- * @category Arrangement & Analysis
- */
-declare function evaluateSafety(q: SafetyQuery, opts?: EvaluateSafetyOptions): SafetyResult;
-/**
- * Options for {@link evaluateSafety}.
- *
- * @category Arrangement & Analysis
- */
-type EvaluateSafetyOptions = {
-    /**
-     * Whether to search for safe replacement pitches when the verdict is not
-     * safe. Turning it off skips up to two dozen extra evaluations per rejected
-     * pitch, which is worth doing when only the verdict is wanted.
-     *
-     * @defaultValue true
-     */
-    suggestions?: boolean;
-};
-/**
- * Enumerate placeable pitches in a range, chord tones first, descending.
- *
- * @param q The safety context minus the candidate pitch.
- * @param pitchLow Lowest MIDI pitch to consider (inclusive).
- * @param pitchHigh Highest MIDI pitch to consider (inclusive).
- * @returns Placeable pitches (non-dissonant), chord tones before others, each group descending.
- * @throws If either bound is non-finite/non-integral, reversed, or exceeds the generation budget.
- * @example
- * ```ts
- * import { enumerateSafePitches, makeChord, majorKey } from '@libraz/libcantus';
- * const pitches = enumerateSafePitches(
- *   { profile: 'pop', chord: makeChord(0, 'maj'), key: majorKey(0), otherVoices: [], strongBeat: true },
- *   60,
- *   72,
- * );
- * pitches; // placeable pitches in [60, 72], chord tones first, each group descending
- * ```
- * @category Arrangement & Analysis
- */
-declare function enumerateSafePitches(q: Omit<SafetyQuery, 'candidatePitch'>, pitchLow: number, pitchHigh: number): number[];
-
-export { type EvaluateSafetyOptions as E, NoteSafety as N, ReasonFlag as R, type SafetyProfile as S, type VoiceSnapshot as V, type SafetyQuery as a, type SafetyResult as b, evaluateSafety as c, enumerateSafePitches as e };

package/dist/index-y_ak9_Hi.d.cts

@@ -1,242 +0,0 @@
-import { K as KeyScale } from './types-BN6_Q9Kl.cjs';
-
-/**
- * Chord quality identifiers understood by the chord builder.
- *
- * @category Chords
- */
-type ChordQuality = 'maj' | 'min' | 'dim' | 'aug' | 'maj7' | 'min7' | 'dom7' | 'dim7' | 'm7b5' | 'minMaj7' | 'aug7' | 'augMaj7' | 'majb5' | '6' | 'min6' | '6/9' | 'sus2' | 'sus4' | 'add9' | 'add11' | 'maj9' | 'min9' | 'dom9' | '7b9' | '7#9' | '7#11' | '7b13' | '11' | '13' | '5' | '7sus4' | '7b5' | '7alt' | '13b9' | 'maj13' | 'maj7#11' | 'min11' | 'min13' | 'minAdd9' | 'min6/9';
-/**
- * The basic role a chord tone plays: the degrees a chord's own template names.
- *
- * The shared vocabulary behind {@link chordToneRole}, the harmony layer's
- * `HarmonyRole`, and the voice analyser's labels, so the three cannot drift.
- *
- * @category Chords
- */
-type ChordToneRole = 'root' | 'third' | 'fifth' | 'sixth' | 'seventh';
-/**
- * A bare spelled pitch used as an enharmonic hint: a diatonic letter
- * (0..6 = C..B) plus a chromatic alteration (-2 double-flat .. +2 double-sharp).
- * Mirrors the letter/alter half of the pitch module's `Note` without an octave.
- *
- * @category Chords
- */
-type PitchSpelling = {
-    letter: number;
-    alter: number;
-};
-/**
- * A chord expressed as a root pitch class plus semitone offsets.
- *
- * `rootSpelling`/`bassSpelling` are optional enharmonic hints recorded by
- * parsers (e.g. `parseChordSymbol('Bb7')`) so formatters can reproduce the
- * original spelling instead of defaulting to sharps. Consumers may ignore
- * them; a hint is only trusted when its pitch class still matches the
- * corresponding `rootPc`/`bassPc`.
- *
- * @category Chords
- */
-type Chord = {
-    rootPc: number;
-    quality: ChordQuality;
-    intervals: number[];
-    bassPc?: number;
-    rootSpelling?: PitchSpelling;
-    bassSpelling?: PitchSpelling;
-};
-/**
- * A chord positioned in time: a root pitch class and quality placed at a beat,
- * with optional harmonic-analysis hints. Serves as the neutral exchange record
- * between progression generators and timeline analysers.
- *
- * @category Composition
- */
-type ChordSpan = {
-    rootPc: number;
-    quality: ChordQuality;
-    startBeat: number;
-    bassPc?: number;
-    /** 0-based scale degree of the chord root, when known. */
-    degree?: number;
-    /** True when the chord is a secondary dominant tonicizing another degree. */
-    secondaryDominant?: boolean;
-};
-/**
- * A chord occupying a half-open beat span `[startBeat, endBeat)`.
- *
- * The exchange record between anything that lays chords out in time — a
- * timeline analysis, a bass-line plan, an accompaniment generator — so those
- * surfaces share one definition instead of agreeing by coincidence.
- *
- * @category Composition
- */
-type ChordSegment = {
-    startBeat: number;
-    endBeat: number;
-    chord: Chord;
-};
-/**
- * All chord qualities the builder understands, in declaration order.
- *
- * The order is stable but carries no meaning: it is neither alphabetical nor
- * sorted by template size. {@link detectChord} uses it as its final tie-break,
- * so it is part of the observable behaviour and does not get reshuffled
- * casually — but do not read it as a ranking.
- *
- * @category Chords
- */
-declare function chordQualities(): ChordQuality[];
-/**
- * Build a chord rooted on a diatonic scale degree.
- *
- * The root pitch class is the degree's diatonic pitch class in `key`; the
- * quality's interval template is attached unchanged. Degrees beyond the scale
- * length wrap around.
- *
- * @param degree 0-based scale degree of the chord root.
- * @param ext Chord quality to apply.
- * @param key Key context supplying the diatonic root.
- * @returns The constructed chord.
- *
- * @category Chords
- */
-declare function chordFromDegree(degree: number, ext: ChordQuality, key: KeyScale): Chord;
-/**
- * Build a chord from an explicit root pitch class and quality.
- *
- * @param rootPc Root pitch class (0..11).
- * @param quality Chord quality supplying the interval template.
- * @param bassPc Optional slash-chord bass pitch class.
- * @returns The constructed chord.
- *
- * @example
- * ```ts
- * import { makeChord } from '@libraz/libcantus';
- * const cmaj7 = makeChord(0, 'maj7');
- * // { rootPc: 0, quality: 'maj7', intervals: [0, 4, 7, 11] }
- * ```
- *
- * @category Chords
- */
-declare function makeChord(rootPc: number, quality: ChordQuality, bassPc?: number): Chord;
-/**
- * Transpose a chord by a number of semitones.
- *
- * The interval template is carried over untouched, so a chord whose intervals
- * were customised keeps them, and a slash bass moves with the root. Enharmonic
- * spelling hints are dropped rather than shifted: the letter a transposed root
- * should take depends on the destination key, which a semitone count does not
- * carry. Pass the result through {@link spellChord} to respell it.
- *
- * @param chord The chord to transpose.
- * @param semitones The signed semitone offset.
- * @returns The transposed chord.
- * @throws If `semitones` is not finite.
- *
- * @example
- * ```ts
- * import { formatChordSymbol, parseChordSymbol, transposeChord } from '@libraz/libcantus';
- * formatChordSymbol(transposeChord(parseChordSymbol('C/G'), 2)); // 'D/A'
- * ```
- *
- * @category Chords
- */
-declare function transposeChord(chord: Chord, semitones: number): Chord;
-/**
- * Get the sorted, deduplicated pitch classes of a chord.
- *
- * A slash bass is one of them: `F/G` sounds a G, the voicers put it in the
- * bass, and a set that omitted it would not re-detect as the chord it came
- * from. Pass `includeBass: false` to enumerate the interval template alone.
- *
- * @param chord The chord to enumerate.
- * @param opts Set `includeBass: false` to omit a slash bass.
- * @returns The chord's pitch classes, sorted ascending in [0, 11].
- *
- * @example
- * ```ts
- * import { makeChord, chordPitchClasses } from '@libraz/libcantus';
- * chordPitchClasses(makeChord(0, 'maj7')); // [0, 4, 7, 11]
- * chordPitchClasses(makeChord(5, 'maj', 7)); // [0, 5, 7, 9] — F/G, G included
- * ```
- *
- * @category Chords
- */
-declare function chordPitchClasses(chord: Chord, opts?: {
-    includeBass?: boolean;
-}): number[];
-/**
- * A pitch's interval class above the chord root, in [0, 11].
- *
- * The shared reading of "where does this pitch sit in the chord", used by the
- * safety evaluator and the voice analyser alike so they cannot disagree.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord providing the root reference.
- * @returns The interval class above the root.
- * @category Chords
- */
-declare function intervalAboveRoot(pitch: number, chord: Chord): number;
-/**
- * Whether a pitch is one of a chord's tones, ignoring octave.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord, or null for no sounding harmony.
- * @returns True when the pitch class belongs to the chord.
- * @category Chords
- */
-declare function isChordMember(pitch: number, chord: Chord | null): boolean;
-/**
- * Determine a pitch's harmonic role within a chord.
- *
- * The role is derived from the pitch's interval above the chord root, reduced
- * modulo 12. A major sixth (9) reads as a `sixth` for sixth chords but as a
- * `seventh` for a diminished-seventh chord; ninths and other tensions have no
- * basic role and return null.
- *
- * @param pitch MIDI pitch or bare pitch class.
- * @param chord The chord providing the root reference.
- * @returns The chord-tone role, or null if the pitch has no basic role.
- *
- * @category Chords
- */
-declare function chordToneRole(pitch: number, chord: Chord): ChordToneRole | null;
-/**
- * Build the diatonic triad rooted on a scale degree by stacking scale thirds.
- *
- * Unlike {@link chordFromDegree}, the chord quality is derived from the scale
- * rather than supplied, so degrees yield their scale-correct triads (e.g. a
- * diminished triad on the leading tone of a major key).
- *
- * @param degree 0-based scale degree of the chord root.
- * @param key Key/scale context.
- * @returns The diatonic triad.
- * @throws If the scale is not heptatonic. Stacking thirds means skipping every
- *   other degree, which only lands on a triad when there are seven of them, so
- *   the pentatonic, blues, whole-tone, octatonic and chromatic scales have no
- *   diatonic triad; use {@link chordFromDegree} with an explicit quality there.
- *
- * @example
- * ```ts
- * import { majorKey, diatonicTriad } from '@libraz/libcantus';
- * const tonic = diatonicTriad(0, majorKey(0)); // C major triad (degree 0 of C major)
- * ```
- *
- * @category Chords
- */
-declare function diatonicTriad(degree: number, key: KeyScale): Chord;
-/**
- * Build the diatonic seventh chord rooted on a scale degree.
- *
- * @param degree 0-based scale degree of the chord root.
- * @param key Key/scale context.
- * @returns The diatonic seventh chord.
- * @throws If the scale is not heptatonic, for the reason given on
- *   {@link diatonicTriad}.
- *
- * @category Chords
- */
-declare function diatonicSeventh(degree: number, key: KeyScale): Chord;
-
-export { type Chord as C, type PitchSpelling as P, type ChordQuality as a, type ChordSegment as b, type ChordSpan as c, type ChordToneRole as d, chordFromDegree as e, chordPitchClasses as f, chordQualities as g, chordToneRole as h, diatonicSeventh as i, diatonicTriad as j, intervalAboveRoot as k, isChordMember as l, makeChord as m, transposeChord as t };