@libraz/libcantus 0.9.4 → 1.0.0

package/dist/index-9wcMhG73.d.ts

@@ -0,0 +1,1095 @@
+import { f as Note, d as KeyScale, h as NoteLike, I as IntervalLike, S as SpelledInterval } from './index-B9MNZboQ.js';
+import { r as ScaleName, u as WorldScaleName, s as ScaleNameInput } from './masks-DYbE485J.js';
+import { c as ChordLike, b as Chord, K as KeyLike } from './index-szBv3496.js';
+
+/**
+ * Which of the two modes a key signature is read in.
+ *
+ * A signature names two keys — three sharps is both A major and F# minor — so
+ * every entry point that turns a signature into a key, or that names the mode
+ * of a key relation, selects between them with this.
+ *
+ * @example
+ * ```ts
+ * import type { KeyMode } from '@libraz/libcantus';
+ * const mode: KeyMode = 'minor';
+ * ```
+ * @category Scales
+ */
+type KeyMode = 'major' | 'minor';
+/**
+ * The key signature of a key, as a signed count of sharps (positive) or flats
+ * (negative) — the `fifths` value a notation format such as MusicXML writes.
+ *
+ * The tonic's letter and accidental place the key on the circle of fifths, and
+ * the mode moves it from there: lydian +1, major 0, mixolydian -1, dorian -2,
+ * natural minor -3, phrygian -4, locrian -5.
+ *
+ * A scale that is not a diatonic mode has no signature of its own, so it takes
+ * the signature of its parallel major or minor: a scale with a minor third and
+ * no major third counts as minor (-3), everything else as major (0). This is
+ * why A harmonic minor reports 0 — its G# is written as an accidental, not in
+ * the signature — and why A melodic minor reports 0 as well.
+ *
+ * The result is not clamped: a theoretical key such as Fb major reports -8.
+ * Clamp to ±7 if the consuming format cannot express more.
+ *
+ * @param tonic The spelled tonic, as a note name, note data, or a `Note`; its
+ *   accidental is worth seven fifths.
+ * @param key The key/scale. This one stays a plain key/scale: it reads any
+ *   12-bit mask, including the tonic-less ones a key name cannot describe.
+ * @returns The signed number of sharps (positive) or flats (negative).
+ * @example
+ * ```ts
+ * import { keySignatureFifths, majorKey, minorKey, parseNote } from '@libraz/libcantus';
+ * keySignatureFifths(parseNote('Bb'), majorKey(10)); // -2
+ * keySignatureFifths('A', minorKey(9)); // 0
+ * ```
+ * @category Scales
+ */
+declare function keySignatureFifths(tonic: NoteLike, key: KeyScale): number;
+/**
+ * The key a signature denotes: the inverse of {@link keySignatureFifths} for
+ * the two modes a signature is conventionally read in.
+ *
+ * A signature names two keys — three sharps is both A major and F# minor — so
+ * the mode decides which one is built. The tonic is spelled the way that key is
+ * written, including the theoretical keys past ±7 (nine sharps is B# major).
+ *
+ * @param fifths The signed number of sharps (positive) or flats (negative).
+ * @param mode Which of the signature's two keys to build; defaults to major.
+ * @returns The spelled tonic and the matching key/scale.
+ * @throws If `fifths` is not an integer in [-12, 12], or `mode` is not one of
+ *   `'major'` or `'minor'`.
+ * @example
+ * ```ts
+ * import { keyFromFifths, formatNote } from '@libraz/libcantus';
+ * formatNote(keyFromFifths(-2).tonic); // 'Bb'
+ * formatNote(keyFromFifths(-2, 'minor').tonic); // 'G'
+ * ```
+ * @category Scales
+ */
+declare function keyFromFifths(fifths: number, mode?: KeyMode): {
+    tonic: Note;
+    key: KeyScale;
+};
+
+/**
+ * Scale systems: which pitch organisations functional harmony was built for,
+ * and which ones it would only be imposed on.
+ *
+ * Roman numerals, tonic/subdominant/dominant function and cadence detection all
+ * presuppose Western common practice. A `KeyScale` is a root pitch class and a
+ * twelve-bit mask, which says nothing about the tradition the scale came from,
+ * so analysis code that wants to branch instead of assuming needs this
+ * classification to branch on.
+ */
+
+/**
+ * The kind of pitch organisation a scale belongs to.
+ *
+ * - `'common-practice'`: the scale functional harmony is defined on — a tonic,
+ *   a dominant carrying a leading tone, and a triad available on every degree.
+ * - `'modal'`: a seven-note rotation or alteration of that material. Degrees
+ *   and Roman numerals still describe it, but a dominant-to-tonic cadence is
+ *   not what holds the music together.
+ * - `'non-functional'`: the collection carries no chord function of its own. A
+ *   gapped or symmetric set takes its harmony from whatever key it is used
+ *   over, and a scale from a tradition organised melodically rather than by
+ *   chords has no functional reading at all.
+ *
+ * @category Scales
+ */
+type ScaleSystem = 'common-practice' | 'modal' | 'non-functional';
+/**
+ * The system each built-in scale belongs to.
+ *
+ * Every name in {@link NAMED_SCALES} and {@link WORLD_SCALES} appears here, so
+ * a scale added without a classification fails to compile rather than falling
+ * silently into a default. Aliases are classified through the name they resolve
+ * to; use {@link scaleSystemOf} to look one up.
+ *
+ * @category Scales
+ */
+declare const SCALE_SYSTEMS: Readonly<Record<ScaleName | WorldScaleName, ScaleSystem>>;
+/**
+ * The system a scale belongs to.
+ *
+ * A name — canonical or an alias — is answered exactly: `'nahawand'` is a maqam
+ * even though its mask is the natural minor's. A `KeyScale` carries no
+ * tradition, so it is answered by its mask, under the Western reading of that
+ * mask; a mask that is no built-in scale answers undefined.
+ *
+ * @param scale The scale name, or a key/scale to read the mask of.
+ * @returns The system, or undefined for a mask that names no built-in scale.
+ * @throws If `scale` is a string naming no built-in scale. An unknown name is a
+ *   typo, and answering it the way an unrecognised mask is answered would hide
+ *   that.
+ * @example
+ * ```ts
+ * import { scaleSystemOf, majorKey } from '@libraz/libcantus';
+ * scaleSystemOf('harmonicMinor'); // 'common-practice'
+ * scaleSystemOf('dorian'); // 'modal'
+ * scaleSystemOf('hijaz'); // 'non-functional'
+ * scaleSystemOf(majorKey(0)); // 'common-practice'
+ * ```
+ * @category Scales
+ */
+declare function scaleSystemOf(scale: KeyScale | ScaleNameInput): ScaleSystem | undefined;
+/**
+ * Whether functional (Roman-numeral) analysis applies to a scale.
+ *
+ * True for common-practice and modal scales, false for everything classed
+ * `'non-functional'` — analysis that would otherwise read a raga as a chord
+ * progression can ask here first.
+ *
+ * The two ways of naming a scale are answered differently, exactly as
+ * {@link scaleSystemOf} answers them. A name carries its tradition, so
+ * `'hijaz'` is false. A `KeyScale` carries only a mask, and a mask shared with
+ * a Western scale is read the Western way — maqam Hijaz and the phrygian
+ * dominant are the same seven pitch classes, so that mask is modal and answers
+ * true. A mask that names no built-in scale answers true as well, which keeps a
+ * caller's own mask being analysed the way it always has been. Pass the name
+ * whenever the tradition is known and the answer should follow it.
+ *
+ * @param scale The scale name, or a key/scale to read the mask of.
+ * @returns True when functional harmony describes the scale.
+ * @throws If `scale` is a string naming no built-in scale.
+ * @example
+ * ```ts
+ * import { supportsFunctionalHarmony, scaleByName } from '@libraz/libcantus';
+ * supportsFunctionalHarmony('harmonicMinor'); // true
+ * supportsFunctionalHarmony('bhairav'); // false
+ * supportsFunctionalHarmony('hijaz'); // false — named, so read as a maqam
+ * supportsFunctionalHarmony(scaleByName('hijaz', 0)); // true — its mask is the phrygian dominant
+ * supportsFunctionalHarmony(scaleByName('ryukyu', 0)); // false — a mask no Western scale shares
+ * ```
+ * @category Scales
+ */
+declare function supportsFunctionalHarmony(scale: KeyScale | ScaleNameInput): boolean;
+
+/**
+ * Test whether every chord pitch class is contained in a scale.
+ *
+ * @param chordPcs The chord's pitch classes (0..11).
+ * @param scaleMask The scale's 12-bit mode mask.
+ * @param scaleRootPc The pitch class the mask is rooted on.
+ * @returns True if the scale is a superset of the chord.
+ *
+ * @category Scales
+ */
+declare function scaleMatchesChord(chordPcs: number[], scaleMask: number, scaleRootPc: number): boolean;
+/**
+ * A named scale rooted on a pitch class that fits over a chord.
+ *
+ * @category Scales
+ */
+type ChordScaleMatch = {
+    name: string;
+    rootPc: number;
+};
+/**
+ * List the scales that fit over a chord, best fit first.
+ *
+ * Only the chord root is considered as the scale root, matching the
+ * conventional chord-scale relationship. Every entry of {@link NAMED_SCALES}
+ * whose pitch-class set is a superset of the chord's is returned once per
+ * distinct pitch-class set (aliased masks such as major/ionian report only the
+ * modal name), ranked by fewest extra scale tones beyond the chord and then by
+ * conventional
+ * preference. For bare triads and smaller chords, heptatonic scales rank before
+ * pentatonics and other sizes: a pentatonic adds no modal color over a triad,
+ * so the seven-note modes are the more useful answer. The chromatic scale is
+ * only returned as a fallback when no other scale contains the chord.
+ *
+ * The ranking is by fit, so the first entry is the tightest-fitting scale
+ * rather than the idiomatic choice: a four-note chord that a pentatonic covers
+ * exactly puts that pentatonic ahead of the mode a player would name. Read the
+ * whole list, or pick by name, when the idiomatic scale is what is wanted;
+ * {@link scalesForChanges} makes that choice for a progression.
+ *
+ * @param chord The chord to fit scales over, as a chord symbol, chord data, or
+ *   a `Chord`.
+ * @returns The matching scales rooted on the chord root, best fit first.
+ *
+ * @example
+ * ```ts
+ * import { makeChord, chordScales } from '@libraz/libcantus';
+ * const scales = chordScales(makeChord(0, 'maj7'));
+ * // scales for Cmaj7, best fit first; each is { name, rootPc: 0 }
+ * ```
+ *
+ * @category Scales
+ */
+declare function chordScales(chord: ChordLike): ChordScaleMatch[];
+/**
+ * Which use an avoid note is judged for: sounding it, or passing through it.
+ *
+ * `'harmonic'` is the Berklee-style rule in full — a tone that must not be
+ * sounded against the chord. `'melodic'` keeps only what a line cannot pass
+ * through either, which is the semitone above the root; every other clash
+ * resolves as the line moves on.
+ *
+ * @category Scales
+ */
+type AvoidNoteUse = 'harmonic' | 'melodic';
+/**
+ * Options for {@link avoidNotes}.
+ *
+ * @category Scales
+ */
+type AvoidNotesOptions = {
+    use?: AvoidNoteUse;
+};
+/**
+ * List a scale's avoid notes over a chord.
+ *
+ * An avoid note is a non-chord scale tone that lies a semitone directly above a
+ * chord tone, or the third a suspension displaced; sounding it against the
+ * chord clashes. The scale is rooted on the chord root. If the scale does not
+ * contain the chord, no avoid notes exist.
+ *
+ * The rule states which tones must not be *sounded* against the chord, which is
+ * not the same question as which tones a line may not touch. Pass
+ * `{ use: 'melodic' }` for the melodic reading: only the semitone above the
+ * root survives it, so the result is always a subset of the harmonic one.
+ *
+ * @param chord The chord providing the chord tones, as a chord symbol, chord
+ *   data, or a `Chord`.
+ * @param scaleName A key of {@link NAMED_SCALES}.
+ * @param opts Set `use: 'melodic'` to judge a line rather than a voicing.
+ * @returns The avoid-note pitch classes, sorted ascending in [0, 11].
+ * @throws If `scaleName` is not a built-in scale. An empty result already
+ *   means "this scale has no avoid notes over this chord"; answering a typo
+ *   the same way would make the two indistinguishable.
+ *
+ * @example
+ * ```ts
+ * import { makeChord, avoidNotes } from '@libraz/libcantus';
+ * avoidNotes(makeChord(0, 'maj7'), 'ionian'); // [5] — F clashes with the third
+ * avoidNotes(makeChord(0, 'maj7'), 'ionian', { use: 'melodic' }); // [] — a line may pass through it
+ * ```
+ *
+ * @category Scales
+ */
+declare function avoidNotes(chord: ChordLike, scaleName: ScaleNameInput, opts?: AvoidNotesOptions): number[];
+/**
+ * Options for {@link availableTensions}.
+ *
+ * @category Scales
+ */
+type AvailableTensionsOptions = {
+    /**
+     * The chord this one resolves to, as a chord symbol, chord data, or a
+     * `Chord`.
+     */
+    resolvesTo?: ChordLike;
+};
+/**
+ * List a scale's available tensions over a chord.
+ *
+ * Available tensions are scale tones that are neither chord tones nor avoid
+ * notes, i.e. the usable color tones (typically the 9/11/13 region). The scale
+ * is rooted on the chord root. If the scale does not contain the chord, there
+ * are no available tensions.
+ *
+ * A tension's availability also depends on what the chord is doing. Pass
+ * `resolvesTo` to say which chord this one resolves to: a dominant seventh
+ * resolving down a fifth to a minor tonic takes its flat ninth, sharp ninth and
+ * flat thirteenth, which read on their own would each be an avoid note. Only
+ * scale tones are ever added, so the result stays within the scale.
+ *
+ * @param chord The chord providing the chord tones, as a chord symbol, chord
+ *   data, or a `Chord`.
+ * @param scaleName A key of {@link NAMED_SCALES}.
+ * @param opts Set `resolvesTo` to the chord this one resolves to.
+ * @returns The available-tension pitch classes, sorted ascending in [0, 11].
+ * @throws If `scaleName` is not a built-in scale, as {@link avoidNotes} does.
+ *
+ * @example
+ * ```ts
+ * import { makeChord, availableTensions } from '@libraz/libcantus';
+ * availableTensions(makeChord(0, 'maj7'), 'ionian'); // [2, 9] — color tones over Cmaj7
+ * availableTensions(makeChord(7, 'dom7'), 'phrygianDominant', { resolvesTo: makeChord(0, 'min') });
+ * // [3, 8] — the b13 and b9 the resolution to C minor makes available
+ * ```
+ *
+ * @category Scales
+ */
+declare function availableTensions(chord: ChordLike, scaleName: ScaleNameInput, opts?: AvailableTensionsOptions): number[];
+/**
+ * A scale fit over a chord, with its non-chord tones sorted by what may be done
+ * with them.
+ *
+ * `avoid`, `passing` and `tensions` partition the scale tones the chord does
+ * not state: `avoid` may not be played at all, `passing` may be passed through
+ * melodically but not sounded against the chord, and `tensions` may be added
+ * freely as color. `avoid` is {@link avoidNotes} under `use: 'melodic'`, and
+ * `avoid` together with `passing` is the harmonic reading.
+ *
+ * @category Scales
+ */
+type ChordScaleReportEntry = {
+    name: string;
+    rootPc: number;
+    avoid: number[];
+    passing: number[];
+    tensions: number[];
+};
+/**
+ * Report the best-fitting scales for a chord with their avoid notes and tensions.
+ *
+ * Combines {@link chordScales}, {@link avoidNotes}, and {@link availableTensions}
+ * into a single ergonomic result, ordered best fit first. The report is read as
+ * playing advice, so the tones a line may pass through are reported apart from
+ * the ones it may not touch; see {@link ChordScaleReportEntry}.
+ *
+ * @param chord The chord to analyze, as a chord symbol, chord data, or a
+ *   `Chord`.
+ * @param limit Optional maximum number of scales to report; all by default.
+ * @returns One entry per reported scale, best fit first.
+ *
+ * @category Scales
+ */
+declare function chordScaleReport(chord: ChordLike, limit?: number): ChordScaleReportEntry[];
+/**
+ * A chord paired with the scale chosen for it by {@link scalesForChanges}.
+ *
+ * @category Scales
+ */
+type ScaleChoice = {
+    chord: Chord;
+    scale: ChordScaleMatch;
+};
+/**
+ * Choose one scale per chord across a progression, favoring continuity.
+ *
+ * Each chord's {@link chordScales} candidates form a stage in a Viterbi-style
+ * dynamic program. The transition cost between adjacent choices is the number
+ * of pitch classes that differ between their pitch-class sets (the symmetric
+ * difference), plus a small penalty for straying from a chord's best-fit scale
+ * so that ties break toward the tighter fit. The minimum-total-cost path is
+ * returned, one {@link ScaleChoice} per input chord in the original order.
+ *
+ * Each choice pairs its scale with the chord exactly as it was handed in, so
+ * this takes plain chord data rather than the wider forms the entry points
+ * above accept.
+ *
+ * @param chords The chord sequence to choose scales for.
+ * @returns One scale choice per chord, in input order.
+ *
+ * @category Scales
+ */
+declare function scalesForChanges(chords: readonly Chord[]): ScaleChoice[];
+
+/**
+ * Voice independence as a measurement rather than a verdict.
+ *
+ * The species rules answer "is this allowed", which is the wrong question of a
+ * pop arrangement: a harmony line in parallel thirds, a power-chord riff and a
+ * pedal point all break them and all are the intended sound. This module
+ * reports how independent two lines actually are and leaves the judgement to
+ * the caller.
+ */
+
+/**
+ * How two lines move against each other, and how far apart they sit.
+ *
+ * @category Voicing & Counterpoint
+ */
+type VoiceIndependenceReport = {
+    /**
+     * Share of the moves that fall into each motion type, summing to 1. A slot
+     * pair in which neither voice moves is not a move and is left out entirely,
+     * so an accompaniment that mostly sits still can still report mostly contrary
+     * motion. All four are 0 when nothing moves.
+     */
+    motion: {
+        /** The voices move in opposite directions. */
+        contrary: number;
+        /** One voice holds while the other moves. */
+        oblique: number;
+        /** Both rise or both fall, and the interval between them changes. */
+        similar: number;
+        /** Both rise or both fall, keeping the same interval. */
+        parallel: number;
+    };
+    /**
+     * Share of the slots where the lead holds or rests on which the counter
+     * attacks: 1 when the counter fills every gap the lead leaves, 0 when it moves
+     * only where the lead does. It is 0 when the lead never holds or rests, since
+     * there was nothing to complement.
+     */
+    rhythmicComplementarity: number;
+    /** Distance between the two lines, in semitones, over the slots where both sound. */
+    separation: {
+        /** Mean distance; 0 when the two lines never sound together. */
+        mean: number;
+        /** Closest approach; 0 when the two lines never sound together. */
+        min: number;
+    };
+    /**
+     * Slots at which the two lines sit in the opposite order to the one they keep
+     * overall. A unison is not a crossing.
+     */
+    crossings: number;
+    /** Longest run of consecutive slots sounding a perfect consonance. */
+    longestPerfectRun: number;
+    /** Slots at which both lines sound, the denominator of `separation`. */
+    sounding: number;
+};
+/**
+ * Options controlling {@link voiceIndependence}.
+ *
+ * @category Voicing & Counterpoint
+ */
+type VoiceIndependenceOptions = {
+    /**
+     * Which slots are fresh attacks in the lead. Without it a slot counts as an
+     * attack when its note differs from the previous slot's, which reads a
+     * deliberately repeated note as a sustain.
+     */
+    leadAttacks?: readonly boolean[];
+    /** Which slots are fresh attacks in the counter; read as `leadAttacks` is. */
+    counterAttacks?: readonly boolean[];
+    /**
+     * Count the perfect fourth among the perfect consonances when measuring
+     * `longestPerfectRun`. Useful for quartal writing, where the fourth is the
+     * interval being sustained.
+     *
+     * @defaultValue false
+     */
+    countFourths?: boolean;
+};
+/**
+ * Measure how independent a counter line is from the lead it accompanies.
+ *
+ * Both lines are index-aligned samples: one slot per beat (or whatever grid the
+ * caller works on), `null` for a rest, and a repeated note for a sustain. That
+ * is what makes the rhythmic reading possible without a duration model, and
+ * what makes a re-attacked repeated note look like a sustain unless
+ * `leadAttacks` / `counterAttacks` say otherwise. Notes must carry octaves,
+ * since separation and motion are measured between sounding pitches.
+ *
+ * Nothing here is a verdict. Parallel thirds report as parallel motion with a
+ * small separation, a pedal point as oblique motion, a power-chord line as a
+ * long perfect run — all facts about the texture, not faults in it.
+ *
+ * @param lead The leading line, one entry per slot.
+ * @param counter The accompanying line, aligned slot for slot with `lead`.
+ * @param opts Attack flags and the treatment of the fourth.
+ * @returns The motion breakdown, rhythmic complementarity, separation,
+ *   crossings, and the longest perfect-consonance run.
+ * @throws If the two lines differ in length, if an attack array is supplied at
+ *   another length than the lines, or if a note carries no octave.
+ * @example
+ * ```ts
+ * import { parseNote, voiceIndependence } from '@libraz/libcantus';
+ * const lead = ['C5', 'D5', 'E5'].map((n) => parseNote(n));
+ * const counter = ['E4', 'F4', 'G4'].map((n) => parseNote(n));
+ * voiceIndependence(lead, counter).motion.parallel; // 1 — a harmony line in sixths
+ * ```
+ * @category Voicing & Counterpoint
+ */
+declare function voiceIndependence(lead: readonly (Note | null)[], counter: readonly (Note | null)[], opts?: VoiceIndependenceOptions): VoiceIndependenceReport;
+
+/**
+ * An inclusive MIDI pitch range for a single voice.
+ *
+ * @category Voicing & Counterpoint
+ */
+type VoiceRange = {
+    readonly min: number;
+    readonly max: number;
+};
+/**
+ * Default four-voice SATB ranges, ascending (index 0 = lowest):
+ * bass E2–C4 (40–60), tenor C3–G4 (48–67), alto G3–D5 (55–74),
+ * soprano C4–G5 (60–79).
+ *
+ * @category Voicing & Counterpoint
+ */
+declare const SATB_RANGES: readonly Readonly<VoiceRange>[];
+/**
+ * Options controlling {@link voiceChord} and {@link voiceProgression}.
+ *
+ * @category Voicing & Counterpoint
+ */
+type VoicingOptions = {
+    /**
+     * Number of voices to realize. Ignored when `ranges` is given.
+     *
+     * @defaultValue 4
+     */
+    voices?: number;
+    /** Explicit per-voice ranges, ascending (index 0 = lowest). Takes precedence over `voices`. */
+    ranges?: VoiceRange[];
+    /**
+     * Maximum spacing in semitones between adjacent upper voices.
+     *
+     * @defaultValue 12
+     */
+    maxSpacing?: number;
+    /**
+     * Maximum candidate voicings evaluated for one chord.
+     *
+     * Raise this for large voicings when exact optimum matters more than bounded
+     * search time.
+     *
+     * @defaultValue 4000
+     */
+    maxCandidates?: number;
+    /**
+     * Maximum number of chords {@link voiceProgression} will voice. The search
+     * per chord is bounded internally, so the cost of a progression is linear in
+     * its length; this is the guard against an unbounded caller, not a limit on
+     * the search.
+     *
+     * @defaultValue 1000000
+     */
+    budget?: number;
+    /**
+     * The prevailing key, as a key name, a key/scale, or a `Key`. Supplying it
+     * enables the rules that only make sense relative to a tonic: the leading
+     * tone is neither doubled nor left unresolved. Without it, voicings are
+     * chosen from chord structure and voice-leading distance alone.
+     */
+    key?: KeyLike;
+    /**
+     * The chord that produced the current voicing passed to {@link nextVoicing},
+     * as a chord symbol, chord data, or a `Chord`. When supplied, chordal-seventh
+     * resolution is scored exactly as it is by {@link voiceProgression}.
+     */
+    previousChord?: ChordLike;
+};
+/**
+ * Realize a single chord as one MIDI pitch per voice, ascending (index 0 =
+ * lowest). The bass voice takes the chord's `bassPc` when set, otherwise the
+ * root; upper voices take chord pitch classes, doubling the root or fifth as
+ * needed to fill all voices. The result stays inside each voice's range, keeps
+ * adjacent upper voices within `maxSpacing`, avoids voice crossing, and is
+ * deterministic: a compact close-position voicing centered in the ranges.
+ *
+ * @param chord The chord to voice.
+ * @param opts Voicing options; defaults to four voices in {@link SATB_RANGES}.
+ * @returns MIDI pitches, ascending, one per voice.
+ * @throws If no voicing fits the given ranges.
+ * @example
+ * ```ts
+ * import { parseChordSymbol, voiceChord } from '@libraz/libcantus';
+ * const chord = parseChordSymbol('Cmaj7');
+ * voiceChord(chord); // four ascending MIDI pitches within the SATB ranges
+ * ```
+ * @category Voicing & Counterpoint
+ */
+declare function voiceChord(chord: ChordLike, opts?: VoicingOptions): number[];
+/**
+ * Voice a chord progression with smooth, bounded SATB-style leading.
+ *
+ * Each chord is chosen from a deterministic candidate set, minimizing motion
+ * while penalizing counterpoint violations. A supplied key additionally
+ * resolves leading tones and chordal sevenths.
+ *
+ * @param chords The chords to voice in order.
+ * @param opts Voicing options; defaults to four voices in {@link SATB_RANGES}.
+ * @returns One ascending MIDI voicing per chord.
+ * @throws {@link NoSolutionError} with the failing chord index when a chord
+ *   cannot fit the requested ranges.
+ * @category Voicing & Counterpoint
+ */
+declare function voiceProgression(chords: readonly ChordLike[], opts?: VoicingOptions): number[][];
+
+/**
+ * A tertian voicing style for {@link voiceChordStyled}.
+ *
+ * - `close`: the plain close-position tertian stack.
+ * - `drop2`: the second voice from the top dropped an octave (drop-2 voicing).
+ * - `drop3`: the third voice from the top dropped an octave (drop-3 voicing).
+ * - `shell`: root plus guide tones (third and seventh) for seventh chords, or
+ *   root/third/fifth for triads; the fifth and tensions are omitted.
+ * - `rootless`: the root omitted, keeping third/fifth/seventh and tensions
+ *   (a typical left-hand jazz voicing).
+ *
+ * @category Voicing & Counterpoint
+ */
+type VoicingStyle = 'close' | 'drop2' | 'drop3' | 'shell' | 'rootless';
+/**
+ * Options controlling {@link voiceChordStyled}.
+ *
+ * @category Voicing & Counterpoint
+ */
+type StyledVoicingOptions = {
+    /**
+     * Voicing style to build.
+     *
+     * @defaultValue 'close'
+     */
+    style?: VoicingStyle;
+    /** Constrain the highest voice to this pitch class (0..11) when given. */
+    topNote?: number;
+    /**
+     * Base octave in scientific pitch notation: octave 4 starts the stack near
+     * middle C (MIDI 60), i.e. near `12 * (octave + 1)`.
+     *
+     * @defaultValue 4
+     */
+    octave?: number;
+    /**
+     * Omit the root regardless of style (relevant for jazz voicings).
+     *
+     * @defaultValue false
+     */
+    rootless?: boolean;
+};
+/**
+ * Realize a single chord as an explicit tertian voicing in a chosen style,
+ * independent of the SATB range search used by {@link voiceChord}.
+ *
+ * The chord tones are stacked in close position from the bass (`bassPc`, else
+ * `rootPc`) in the given scientific-pitch `octave` upward (octave 4 starts the
+ * bass near C4 = MIDI 60, matching {@link midiToNote} and the bass module).
+ * When `topNote` is given the stack is rotated so the highest voice's pitch
+ * class equals that note (or the nearest chord tone). The chosen
+ * {@link VoicingStyle} then transforms the stack, and the result is returned as
+ * ascending MIDI pitches (index 0 = lowest).
+ *
+ * Every returned pitch is a valid MIDI number: an octave whose stack would run
+ * off either end of the 0..127 range is rejected rather than voiced out of
+ * range, matching {@link nextVoicing}, which clamps its derived ranges.
+ *
+ * @param chord The chord to voice.
+ * @param opts Styled voicing options; defaults to a close voicing at octave 4.
+ * @returns MIDI pitches, ascending, one per retained voice.
+ * @throws If the voicing would not fit inside MIDI 0..127 at the given octave.
+ * @example
+ * ```ts
+ * import { parseChordSymbol, voiceChordStyled } from '@libraz/libcantus';
+ * const chord = parseChordSymbol('Dm7');
+ * voiceChordStyled(chord, { style: 'drop2' }); // ascending MIDI pitches, drop-2 voicing
+ * ```
+ * @category Voicing & Counterpoint
+ */
+declare function voiceChordStyled(chord: Chord, opts?: StyledVoicingOptions): number[];
+
+/**
+ * Species counterpoint: mark a two-voice exercise against the sixteenth-century
+ * rules.
+ *
+ * This is the conservatory exercise, not a general style checker. It grades a
+ * counterpoint written above or below a given cantus firmus in one of the five
+ * species, and reports what it finds as the same {@link PartWritingViolation}
+ * the four-part checker uses.
+ *
+ * Both voices arrive as spelled notes, because half of what the rules forbid is
+ * invisible in a pitch: the augmented second of the harmonic minor is a minor
+ * third by ear, and the diminished fourth that may not stand as a consonance is
+ * a major third by ear.
+ */
+
+/**
+ * Which species an exercise is written in: note against note, two, three or
+ * four notes against one, suspensions, or the florid mixture of them all.
+ *
+ * @category Voicing & Counterpoint
+ */
+type Species = 1 | 2 | 3 | 4 | 5;
+/**
+ * Options controlling {@link checkSpecies}.
+ *
+ * @category Voicing & Counterpoint
+ */
+type SpeciesOptions = {
+    /**
+     * Length of each counterpoint note, measured in cantus-firmus notes: 1 is a
+     * whole note filling a measure, 0.5 a half, 0.25 a quarter.
+     *
+     * The first four species have a fixed ratio, so the durations are implied by
+     * the note count and this is only needed to describe something unusual. The
+     * fifth species mixes note values by definition and cannot be read without it.
+     */
+    durations?: readonly number[];
+    /**
+     * Which side of the cantus firmus the counterpoint is written on. Defaults to
+     * whichever side it actually lies on, by mean pitch.
+     */
+    counterpointAbove?: boolean;
+};
+/**
+ * Check a species counterpoint exercise and report every rule it breaks.
+ *
+ * The cantus firmus is one note per measure. The counterpoint is aligned to it
+ * by position rather than by written rhythm: the first four species have a fixed
+ * number of notes per measure, so the note count alone says where each note
+ * falls, and a closing measure written as a single whole note is accepted as the
+ * convention it is. The fifth species mixes note values and therefore needs
+ * `opts.durations`, given in cantus-firmus notes.
+ *
+ * Judged are the vertical intervals under each species' dissonance licence
+ * (none in the first, a passing dissonance on the weak half in the second and
+ * third, a prepared suspension on the downbeat in the fourth, both in the
+ * fifth; the third and fifth species also write the *nota cambiata* and the
+ * double neighbour, which quit a dissonance by leap), parallel and hidden
+ * perfects and the *battuta* between the voices, augmented and otherwise
+ * forbidden leaps along the counterpoint, the shape of the counterpoint as a
+ * line, and the opening and closing formulas. Violations name the cantus firmus
+ * as voice 0 and the counterpoint as voice 1, and index into the counterpoint.
+ *
+ * @param cantusFirmus The given voice, one spelled note per measure.
+ * @param counterpoint The written voice, in spelled notes.
+ * @param species Which species the exercise is written in.
+ * @param mode The mode the exercise is in.
+ * @param opts Note lengths, and which side the counterpoint is written on.
+ * @returns Every violation found, in the order the exercise commits them; an
+ *   empty array for a clean exercise.
+ * @throws If the species is not one of the five, either voice is empty, a note
+ *   carries no octave, or the fifth species is given without durations.
+ * @example
+ * ```ts
+ * import { checkSpecies, majorKey, parseNote } from '@libraz/libcantus';
+ * const cf = ['C4', 'D4', 'E4', 'D4', 'C4'].map((n) => parseNote(n));
+ * const cp = ['C5', 'A4', 'G4', 'B4', 'C5'].map((n) => parseNote(n));
+ * checkSpecies(cf, cp, 1, majorKey(0)); // [] — a clean first-species exercise
+ * ```
+ * @category Voicing & Counterpoint
+ */
+declare function checkSpecies(cantusFirmus: readonly Note[], counterpoint: readonly Note[], species: Species, mode: KeyScale, opts?: SpeciesOptions): PartWritingViolation[];
+
+/**
+ * Part writing: grade a finished exercise against the classical four-part rules.
+ *
+ * The counterpoint predicates each judge one pair of voices at one moment; this
+ * module walks a whole progression and reports every violation it finds, so a
+ * completed exercise can be marked in a single call.
+ *
+ * The input is spelled notes rather than MIDI pitches because two of the rules
+ * cannot be decided without them: a cross relation is one letter carrying two
+ * different accidentals, and an augmented second is a minor third under another
+ * name. A caller holding only pitches spells them with {@link spellVoicing}.
+ */
+
+/**
+ * The rule a {@link PartWritingViolation} breaks.
+ *
+ * - `parallelFifth`, `parallelOctave`: consecutive perfect intervals of the same
+ *   kind between one pair of voices. A parallel unison is reported as a
+ *   `parallelOctave`, since it is the same perfect class.
+ * - `hiddenPerfect`: the outer voices reach a perfect fifth or octave by similar
+ *   motion with a leap in the upper voice.
+ * - `crossRelation`: one letter carries two different accidentals in two
+ *   different voices across a chord change, exposed — neither note led into by
+ *   step, at least one of them in an outer voice, and neither chord one of the
+ *   chromatic harmonies that are written with the contradiction.
+ * - `voiceCrossing`, `overlap`, `spacing`, `range`: the texture rules.
+ * - `unresolvedLeadingTone`, `unresolvedSeventh`: a tendency tone that does not
+ *   go where it must.
+ * - `augmentedMelodicInterval`: a single voice moves by an augmented interval.
+ *
+ * The rest are raised by {@link checkSpecies} alone, since they describe faults
+ * only a species exercise can commit:
+ *
+ * - `wrongRhythmicRatio`: the counterpoint does not present the number of notes
+ *   per cantus-firmus note its species requires.
+ * - `unpreparedDissonance`: a dissonance falls where the species allows none, or
+ *   is reached or left by leap where it must be passed through by step.
+ * - `unresolvedSuspension`: a fourth-species suspension that does not fall by
+ *   step onto the following consonance.
+ * - `illegalLeap`: a melodic leap the style forbids — either seventh, the
+ *   tritone, or anything wider than an octave.
+ * - `battuta`: an octave or unison reached by contrary motion with the upper
+ *   voice leaping down.
+ * - `missingCadence`: the exercise does not open or close on the formula its
+ *   species requires.
+ * - `melodicShape`: the counterpoint is a poor line — it has no single climax,
+ *   leaps too often or too far one way, leaves a wide leap unanswered, outlines
+ *   a tritone, or repeats a note where the species keeps moving. The rationale
+ *   says which.
+ *
+ * @category Voicing & Counterpoint
+ */
+type PartWritingViolationKind = 'parallelFifth' | 'parallelOctave' | 'hiddenPerfect' | 'crossRelation' | 'voiceCrossing' | 'overlap' | 'spacing' | 'range' | 'unresolvedLeadingTone' | 'unresolvedSeventh' | 'augmentedMelodicInterval' | 'wrongRhythmicRatio' | 'unpreparedDissonance' | 'unresolvedSuspension' | 'illegalLeap' | 'battuta' | 'missingCadence' | 'melodicShape';
+/**
+ * One broken rule, located in the progression and in the texture.
+ *
+ * @category Voicing & Counterpoint
+ */
+type PartWritingViolation = {
+    /** The rule that was broken. */
+    kind: PartWritingViolationKind;
+    /**
+     * The voices involved, by index into a voicing (0 = lowest). A rule about a
+     * pair names both, ascending; a rule about a single line names one. A
+     * `crossRelation` is the exception: it names the voice holding the earlier
+     * note first, whichever is higher. In a species exercise there are only two
+     * voices and they are named by role instead: 0 is the cantus firmus and 1 the
+     * counterpoint, whichever lies above.
+     */
+    voices: number[];
+    /**
+     * Index of the chord the motion starts on; in a species exercise, the index
+     * into the counterpoint.
+     */
+    fromIndex: number;
+    /** Index of the chord it ends on; equal to `fromIndex` for a vertical rule. */
+    toIndex: number;
+    /** A short sentence naming the musical reason. */
+    rationale: string;
+};
+/**
+ * A chord realized as one spelled note per voice, ascending (index 0 = lowest),
+ * matching the voice order {@link voiceChord} and {@link SATB_RANGES} use.
+ *
+ * Every note must carry an octave: the rules measure real distances between
+ * sounding pitches, which a bare pitch class does not have.
+ *
+ * @category Voicing & Counterpoint
+ */
+type SpelledVoicing = Note[];
+/**
+ * Options controlling {@link checkPartWriting}.
+ *
+ * @category Voicing & Counterpoint
+ */
+type PartWritingOptions = {
+    /**
+     * Per-voice ranges, ascending (index 0 = lowest), against which the `range`
+     * rule is judged. Defaults to {@link SATB_RANGES} for a four-voice exercise;
+     * for any other voice count there is no conventional compass to assume, so
+     * the rule is skipped unless ranges are given. Given ranges must cover every
+     * voice of the widest chord, and each must be finite with `min` no greater
+     * than `max`.
+     */
+    ranges?: VoiceRange[];
+    /**
+     * Maximum spacing in semitones between adjacent upper voices. The bass-tenor
+     * pair is exempt, as convention has it. Must be finite and non-negative.
+     *
+     * @defaultValue 12
+     */
+    maxSpacing?: number;
+};
+/**
+ * Spell a voicing given as MIDI pitches, so it can be checked by
+ * {@link checkPartWriting}.
+ *
+ * Each pitch is named against the chord sounding under it and then the key, so a
+ * chord tone takes the letter its interval above the root implies: the third of
+ * a D major chord in C major spells F#, not Gb. The octave is kept, since the
+ * rules measure real distances.
+ *
+ * @param voicing MIDI pitches, ascending (index 0 = lowest).
+ * @param chord The chord sounding, supplying the enharmonic evidence.
+ * @param key The key the exercise is written in.
+ * @returns One spelled note per pitch, in the same order.
+ * @example
+ * ```ts
+ * import { majorKey, makeChord, noteNames, spellVoicing } from '@libraz/libcantus';
+ * noteNames(spellVoicing([50, 57, 66, 69], makeChord(2, 'maj'), majorKey(0)));
+ * // ['D3', 'A3', 'F#4', 'A4'] — the third of D spells F# in C major
+ * ```
+ * @category Voicing & Counterpoint
+ */
+declare function spellVoicing(voicing: readonly number[], chord: Chord, key: KeyScale): SpelledVoicing;
+/**
+ * Check a finished part-writing exercise and report every rule it breaks.
+ *
+ * The voicings are given one per chord, each ascending with one spelled note per
+ * voice (index 0 = lowest, the bass), the voice order {@link voiceChord} and
+ * {@link SATB_RANGES} already use. Notes must carry octaves.
+ *
+ * Each chord is checked for voice crossing, over-wide spacing between adjacent
+ * upper voices, and voices outside their range; each pair of consecutive chords
+ * for parallel and hidden perfects, voice overlap, cross relations, augmented
+ * melodic intervals, and unresolved tendency tones. Violations come back in
+ * musical order: the rules inside a chord, then the rules taking it to the next.
+ *
+ * @param voicings One voicing per chord, ascending, in spelled notes.
+ * @param chords The chords those voicings realize, in the same order.
+ * @param key The key the exercise is written in; it names the leading tone.
+ * @param opts Ranges and the upper-voice spacing limit. Both are validated
+ *   before any rule runs: an empty result has to mean that nothing was broken,
+ *   never that a rule could not be evaluated.
+ * @returns Every violation found, in musical order; an empty array for a clean
+ *   exercise.
+ * @throws If the two arrays differ in length, a note carries no octave, the
+ *   spacing limit is not a non-negative finite number, or the ranges are empty,
+ *   malformed, or too few for the voices being checked.
+ * @example
+ * ```ts
+ * import { checkPartWriting, majorKey, makeChord, spellVoicing } from '@libraz/libcantus';
+ * const key = majorKey(0);
+ * const chords = [makeChord(0, 'maj'), makeChord(2, 'min')];
+ * const voicings = [[48, 55, 64, 72], [50, 57, 65, 69]].map((pitches, i) =>
+ *   spellVoicing(pitches, chords[i] ?? chords[0], key),
+ * );
+ * const violations = checkPartWriting(voicings, chords, key);
+ * violations.map((violation) => violation.kind); // ['parallelFifth']
+ * violations[0]?.voices; // [0, 1]
+ * ```
+ * @category Voicing & Counterpoint
+ */
+declare function checkPartWriting(voicings: readonly SpelledVoicing[], chords: readonly Chord[], key: KeyScale, opts?: PartWritingOptions): PartWritingViolation[];
+
+/**
+ * Transposing instruments: the fixed interval between the pitch a player reads
+ * and the pitch the instrument sounds.
+ *
+ * The distance is a spelled interval, never a semitone count. A clarinet in A
+ * sounds a minor third below what it reads, so a written C sounds A, a written
+ * D sounds B, and a written D# sounds B#: the letter always moves by the
+ * interval's diatonic number, where a bare count of three semitones would take
+ * the last of those to C natural and lose the letter the part is written on.
+ *
+ * The octave is part of that interval rather than folded away into a pitch
+ * class, so instruments pitched in the same key stay apart: the alto saxophone
+ * sounds a major sixth lower, the baritone saxophone a major thirteenth (the
+ * same key an octave further down), and the E flat clarinet a minor third
+ * higher. The pure octave transposers — piccolo, double bass, contrabassoon,
+ * guitar — are a perfect octave, a unison-class interval displaced by one
+ * octave.
+ */
+
+/**
+ * The interval from a written pitch to the pitch the instrument sounds, one
+ * entry per built-in instrument.
+ *
+ * Each value is an interval name as {@link parseInterval} reads it, in the
+ * written-to-sounding direction: a leading `'-'` marks an instrument that
+ * sounds below what it reads, which is most of them. A transposition wider than
+ * an octave is named by its compound interval rather than reduced, because the
+ * octave is exactly what separates the tenor saxophone from the soprano and the
+ * baritone from the alto.
+ *
+ * @example
+ * ```ts
+ * import { TRANSPOSING_INSTRUMENTS } from '@libraz/libcantus';
+ * TRANSPOSING_INSTRUMENTS.clarinetA; // '-m3' — sounds a minor third lower
+ * TRANSPOSING_INSTRUMENTS.piccolo; // 'P8' — sounds an octave higher
+ * ```
+ * @category Pitch & Intervals
+ */
+declare const TRANSPOSING_INSTRUMENTS: Readonly<{
+    clarinetBb: "-M2";
+    trumpetBb: "-M2";
+    sopranoSax: "-M2";
+    tenorSax: "-M9";
+    bassClarinet: "-M9";
+    clarinetA: "-m3";
+    hornF: "-P5";
+    englishHorn: "-P5";
+    clarinetEb: "m3";
+    altoSax: "-M6";
+    baritoneSax: "-M13";
+    trumpetD: "M2";
+    piccolo: "P8";
+    doubleBass: "-P8";
+    contrabassoon: "-P8";
+    guitar: "-P8";
+}>;
+/**
+ * The name of a built-in transposing instrument, as
+ * {@link TRANSPOSING_INSTRUMENTS} keys them.
+ *
+ * @example
+ * ```ts
+ * import type { TransposingInstrumentName } from '@libraz/libcantus';
+ * const part: TransposingInstrumentName = 'clarinetA';
+ * ```
+ * @category Pitch & Intervals
+ */
+type TransposingInstrumentName = keyof typeof TRANSPOSING_INSTRUMENTS;
+/**
+ * A transposing instrument: one of the built-in names, or a spelled interval
+ * for an instrument the table does not carry.
+ *
+ * An interval is read in the same written-to-sounding direction as the table,
+ * so `'-M2'` is any instrument in B flat and `'P8'` any that sounds an octave
+ * up. The names complete in an editor while any other string is still accepted,
+ * which is what lets an instrument read from configuration go straight in.
+ *
+ * @example
+ * ```ts
+ * import type { TransposingInstrument } from '@libraz/libcantus';
+ * const clarinet: TransposingInstrument = 'clarinetA';
+ * const altoFlute: TransposingInstrument = '-P4';
+ * ```
+ * @category Pitch & Intervals
+ */
+type TransposingInstrument = TransposingInstrumentName | (string & {}) | Exclude<IntervalLike, string>;
+/**
+ * The interval a transposing instrument sounds at, measured from what it reads.
+ *
+ * This is the table's own direction: the answer descends for an instrument that
+ * sounds below the printed part, which is most of them. Applying it to a
+ * written pitch is {@link toSoundingPitch}, and applying it to a concert key is
+ * how a written key is read back as the key it sounds in.
+ *
+ * @param instrument A built-in instrument name, or an interval naming a
+ *   transposition the table does not carry.
+ * @returns The written-to-sounding interval.
+ * @throws If the value is neither a known instrument nor a spelled interval.
+ * @example
+ * ```ts
+ * import { instrumentTransposition } from '@libraz/libcantus';
+ * instrumentTransposition('clarinetA');
+ * // { number: 3, quality: 'm', semitones: -3, descending: true }
+ * instrumentTransposition('piccolo'); // { number: 8, quality: 'P', semitones: 12 }
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function instrumentTransposition(instrument: TransposingInstrument): SpelledInterval;
+/**
+ * The pitch an instrument sounds for a written note.
+ *
+ * The interval decides the letter, so the spelling of the part survives the
+ * conversion: on a clarinet in A a written C sounds A, a written D sounds B,
+ * and a written D# sounds B# — a semitone count alone could answer C natural
+ * for that last one and lose the letter the part is written on. A note carrying
+ * an octave moves register with it — a written C4 sounds A3 — while an
+ * octave-less note stays octave-less, so a pure octave transposer leaves it
+ * alone.
+ *
+ * @param note The written note, as the player reads it: a note name, a MIDI
+ *   number, note data, or a `Note`.
+ * @param instrument A built-in instrument name, or an interval naming a
+ *   transposition the table does not carry.
+ * @returns The sounding note, at concert pitch.
+ * @throws If the note is malformed, or the instrument is neither a known name
+ *   nor a spelled interval.
+ * @example
+ * ```ts
+ * import { formatNote, parseNote, toSoundingPitch } from '@libraz/libcantus';
+ * formatNote(toSoundingPitch(parseNote('C4'), 'clarinetA')); // 'A3'
+ * formatNote(toSoundingPitch('D#4', 'clarinetA')); // 'B#3'
+ * formatNote(toSoundingPitch(parseNote('C4'), 'piccolo')); // 'C5'
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function toSoundingPitch(note: NoteLike, instrument: TransposingInstrument): Note;
+/**
+ * The note an instrument must read to sound a given concert pitch.
+ *
+ * The exact inverse of {@link toSoundingPitch} for every instrument: the same
+ * interval applied the other way, so the letter and the octave both come back.
+ * A concert A3 is written C4 for a clarinet in A, and a concert E flat 3 is
+ * written C4 for an alto saxophone but C5 for a baritone saxophone, which reads
+ * the same key an octave lower.
+ *
+ * @param note The sounding note, at concert pitch: a note name, a MIDI number,
+ *   note data, or a `Note`.
+ * @param instrument A built-in instrument name, or an interval naming a
+ *   transposition the table does not carry.
+ * @returns The written note, as the player reads it.
+ * @throws If the note is malformed, or the instrument is neither a known name
+ *   nor a spelled interval.
+ * @example
+ * ```ts
+ * import { formatNote, parseNote, toWrittenPitch } from '@libraz/libcantus';
+ * formatNote(toWrittenPitch(parseNote('A3'), 'clarinetA')); // 'C4'
+ * formatNote(toWrittenPitch('Eb3', 'altoSax')); // 'C4'
+ * formatNote(toWrittenPitch(parseNote('Eb3'), 'baritoneSax')); // 'C5'
+ * ```
+ * @category Pitch & Intervals
+ */
+declare function toWrittenPitch(note: NoteLike, instrument: TransposingInstrument): Note;
+
+export { type AvailableTensionsOptions as A, keySignatureFifths as B, type ChordScaleMatch as C, scaleMatchesChord as D, scaleSystemOf as E, scalesForChanges as F, spellVoicing as G, supportsFunctionalHarmony as H, toSoundingPitch as I, toWrittenPitch as J, type KeyMode as K, voiceChord as L, voiceChordStyled as M, voiceIndependence as N, voiceProgression as O, type PartWritingOptions as P, SATB_RANGES as S, TRANSPOSING_INSTRUMENTS as T, type VoiceIndependenceOptions as V, type AvoidNoteUse as a, type AvoidNotesOptions as b, type ChordScaleReportEntry as c, type PartWritingViolation as d, type PartWritingViolationKind as e, SCALE_SYSTEMS as f, type ScaleChoice as g, type ScaleSystem as h, type Species as i, type SpeciesOptions as j, type SpelledVoicing as k, type StyledVoicingOptions as l, type TransposingInstrument as m, type TransposingInstrumentName as n, type VoiceIndependenceReport as o, type VoiceRange as p, type VoicingOptions as q, type VoicingStyle as r, availableTensions as s, avoidNotes as t, checkPartWriting as u, checkSpecies as v, chordScaleReport as w, chordScales as x, instrumentTransposition as y, keyFromFifths as z };