@libraz/libcantus 0.9.4 → 1.0.0

package/dist/index-70p168VM.d.ts

@@ -1,192 +0,0 @@
-import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.js';
-import { a as ChordQuality, C as Chord } from './index-C83mZI1P.js';
-
-/**
- * Recognition: infer a chord name from a set of pitches, or a key from a set of
- * pitch classes. This is the inverse direction of the chord/scale builders,
- * which only go name -> notes.
- */
-
-/**
- * A candidate chord interpretation of a pitch set.
- *
- * @category Recognition
- */
-type ChordMatch = {
-    rootPc: number;
-    quality: ChordQuality;
-    /** Chord tones absent from the input (an incomplete voicing). */
-    missingPcs: number[];
-    /** Input pitch classes not belonging to the chord. */
-    extraPcs: number[];
-    /** True when the input pitch-class set equals the chord exactly. */
-    exact: boolean;
-    /**
-     * Inversion implied by a known bass: 0 for root position, 1..n for an
-     * inversion. Null when no inversion can be named — either the input is an
-     * unordered pitch-class set with no bass, or the bass is not a chord tone (a
-     * pedal or passing bass), in which case `bassPc` still reports it.
-     */
-    inversion: number | null;
-    /** Bass pitch class when the lowest note is not the root. */
-    bassPc?: number;
-};
-/**
- * Input interpretation for {@link detectChord} and {@link detectChordBest}.
- *
- * @category Recognition
- */
-type DetectChordOptions = {
-    /**
-     * `midi` uses the numerically lowest pitch as bass; `pitchClass` treats the
-     * input as unordered. `auto` (default) selects pitch-class mode only when all
-     * values lie in 0..11.
-     */
-    input?: 'auto' | 'midi' | 'pitchClass';
-    /** Explicit bass pitch class, including for an unordered pitch-class set. */
-    bassPc?: number;
-};
-/**
- * A candidate key interpretation of a pitch-class set.
- *
- * @category Recognition
- */
-type KeyMatch = {
-    /** The scale that scored best for this tonic and mode, `variant` included. */
-    key: KeyScale;
-    mode: 'major' | 'minor';
-    /** Which scale form `key` uses; minor keys pick the best-scoring of the three. */
-    variant: KeyVariant;
-    /**
-     * Fraction of the distinct input pitch classes that belong to `key`, in
-     * [0, 1]. Measured against the returned scale, so it always agrees with
-     * `isScaleTone(pc, match.key)`. This is a coverage figure, not the ranking:
-     * see `score`.
-     */
-    fit: number;
-    /**
-     * The value the results are ranked by, in [0, 1.5]. Unlike `fit` it counts
-     * every occurrence rather than every distinct pitch class, so a repeated tone
-     * weighs more, and it adds half a count per sounding of the tonic itself to
-     * break ties between keys that contain the same notes.
-     */
-    score: number;
-};
-/**
- * Which form of a scale a {@link KeyMatch} settled on.
- *
- * @category Recognition
- */
-type KeyVariant = 'major' | 'natural' | 'harmonic' | 'melodic';
-/**
- * Input weighting for {@link detectKey}.
- *
- * @category Recognition
- */
-type DetectKeyOptions = {
-    /**
-     * How much each pitch counts toward the histogram, one entry per pitch.
-     * Defaults to one per pitch, which weighs a thirty-second-note ornament as
-     * heavily as the whole note under it. {@link detectKeyFromNotes} supplies
-     * duration times velocity, matching how chord inference weighs its own
-     * histogram.
-     */
-    weights?: readonly number[];
-};
-/**
- * Identify chords matching a set of pitches.
- *
- * Every input pitch class is tried as a root against every known chord quality.
- * A match is reported when all of the chord's tones are present in the input, or
- * when the only absent tone is the perfect fifth (a common omission in shell
- * voicings); matches are ranked best-first by fewest extra notes, then fewest
- * missing notes, then most specific (largest) chord. An exact match (no extras,
- * no missing) is flagged and ranked first.
- *
- * @param pitches MIDI pitches or bare pitch classes (octave-agnostic).
- * @returns Ranked chord interpretations (may be empty).
- * @example
- * ```ts
- * import { detectChord } from '@libraz/libcantus';
- * const matches = detectChord([60, 64, 67]); // C E G
- * matches[0]; // { rootPc: 0, quality: 'maj', exact: true, ... }
- * ```
- * @category Recognition
- */
-declare function detectChord(pitches: readonly number[], opts?: DetectChordOptions): ChordMatch[];
-/**
- * The single best chord interpretation of a pitch set, or null if none.
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @returns The top-ranked chord, or null when nothing matches.
- * @example
- * ```ts
- * import { detectChordBest } from '@libraz/libcantus';
- * detectChordBest([60, 64, 67]); // C major triad: { rootPc: 0, quality: 'maj', ... }
- * ```
- * @category Recognition
- */
-declare function detectChordBest(pitches: readonly number[], opts?: DetectChordOptions): Chord | null;
-/**
- * Rank major and minor keys by how well they contain a set of pitch classes.
- *
- * Ranking is by `score`, which counts repetitions and adds a tonic weight so
- * that, among equally-fitting keys, the one whose root is actually sounded is
- * preferred. Minor candidates are scored against the natural, harmonic, and
- * melodic minor variants and keep the best of the three, so a minor cadence
- * containing the leading tone still resolves to its own tonic; the winning
- * variant is what `key` and `variant` report, so `fit` describes the scale the
- * caller receives. Returns all 24 keys ranked best-first, or an empty array for
- * an empty input (mirroring {@link detectChord}).
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @returns Ranked key interpretations (empty for an empty input).
- * @example
- * ```ts
- * import { detectKey } from '@libraz/libcantus';
- * const keys = detectKey([60, 62, 64, 65, 67, 69, 71]); // C major scale
- * keys[0].mode; // 'major', with keys[0].key.rootPc === 0
- * ```
- * @category Recognition
- */
-declare function detectKey(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch[];
-/**
- * Rank keys by how well they contain a set of note events, weighting each note
- * by how much of the music it actually occupies.
- *
- * {@link detectKey} counts every pitch once, which lets a run of fast ornamental
- * notes outvote the sustained harmony that establishes the key. This weighs
- * each note by duration times velocity, the same measure chord inference uses,
- * so the two agree on what the music emphasises. Notes that never sound (zero
- * or negative duration) are ignored.
- *
- * @param notes The note events to weigh.
- * @returns Ranked key interpretations (empty when nothing sounds).
- * @example
- * ```ts
- * import { detectKeyFromNotes } from '@libraz/libcantus';
- * detectKeyFromNotes([{ pitch: 60, startBeat: 0, durationBeat: 4 }])[0]?.key.rootPc; // 0
- * ```
- * @category Recognition
- */
-declare function detectKeyFromNotes(notes: readonly NoteEvent[]): KeyMatch[];
-/**
- * The single best key interpretation of a pitch set.
- *
- * The counterpart of {@link detectChordBest}: the ranked list is the general
- * answer, but a caller that just wants "what key is this" should not have to
- * index into it and assert the result is there.
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @param opts How to weigh the input; see {@link DetectKeyOptions}.
- * @returns The top-ranked key, or null when nothing sounds.
- * @example
- * ```ts
- * import { detectKeyBest } from '@libraz/libcantus';
- * detectKeyBest([0, 2, 4, 5, 7, 9, 11])?.mode; // 'major'
- * ```
- * @category Recognition
- */
-declare function detectKeyBest(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch | null;
-
-export { type ChordMatch as C, type DetectChordOptions as D, type KeyMatch as K, type DetectKeyOptions as a, type KeyVariant as b, detectChordBest as c, detectChord as d, detectKey as e, detectKeyBest as f, detectKeyFromNotes as g };

package/dist/index-Be74mcon.d.cts

@@ -1,152 +0,0 @@
-import { T as TimeSignature } from './index-DXd9JikN.cjs';
-import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.cjs';
-import { C as Chord, b as ChordSegment, c as ChordSpan } from './index-y_ak9_Hi.cjs';
-import { C as Cadence } from './function-DNugAOrt.cjs';
-
-/**
- * A beat-indexed sequence of chord segments.
- *
- * @category Arrangement & Analysis
- */
-type ChordTimeline = {
-    /** The chord sounding at a beat, or null when no segment covers it. */
-    at: (beat: number) => Chord | null;
-    segments: ChordSegment[];
-};
-/**
- * Build a chord timeline from placed chords.
- *
- * Each chord spans from its `startBeat` to the next chord's `startBeat`; the last
- * chord runs to `totalBeats`. Segments with no positive length (from duplicate
- * onsets or a last chord at or past `totalBeats`) are dropped. `at(beat)` returns
- * the covering segment's chord, or null when the beat lies outside every segment.
- *
- * @param chords Placed chords in time order.
- * @param totalBeats End of the timeline in beats.
- * @returns A queryable chord timeline.
- * @category Arrangement & Analysis
- */
-declare function chordTimelineFromChords(chords: readonly ChordSpan[], totalBeats: number): ChordTimeline;
-/**
- * Options controlling {@link chordTimelineFromNotes}.
- *
- * @category Arrangement & Analysis
- */
-type ChordTimelineOptions = {
-    /** Key context; inferred from the notes with {@link detectKeyFromNotes} when omitted. */
-    key?: KeyScale;
-    /**
-     * Time signature used for metric accents; defaults to 4/4.
-     *
-     * @defaultValue `4/4`
-     */
-    ts?: TimeSignature;
-    /**
-     * Window length in beats per chord slot; defaults to one bar of `ts`.
-     *
-     * @defaultValue one bar of `ts`
-     */
-    harmonicRhythm?: number;
-    /**
-     * End of the analyzed span in beats; defaults to the end of the last note.
-     *
-     * @defaultValue the end of the last note
-     */
-    totalBeats?: number;
-    /**
-     * Upper bound on the work this call may do — note counts, windows, and
-     * candidate counts are each checked against it before anything is allocated.
-     *
-     * Raise it to analyse a piece larger than the default allows; the default is
-     * {@link DEFAULT_GENERATION_BUDGET}, chosen so a runaway input fails fast
-     * rather than blocking the thread.
-     *
-     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
-     */
-    budget?: number;
-};
-/**
- * The result of {@link chordTimelineFromNotes}.
- *
- * @category Arrangement & Analysis
- */
-type ChordTimelineResult = {
-    /** The inferred timeline, with adjacent identical chords merged. */
-    timeline: ChordTimeline;
-    /** The key used for the analysis (given or inferred). */
-    key: KeyScale;
-    /** One confidence value in [0, 1] per segment, in segment order. */
-    segmentConfidence: number[];
-};
-/**
- * Infer a chord timeline from raw multi-track notes.
- *
- * The span `[0, totalBeats)` is sliced into `harmonicRhythm`-beat windows; each
- * window's chord is inferred from a pitch-class weight histogram of the notes
- * overlapping it (weight = overlap duration x velocity x metric-accent bonus
- * for onsets in the window). Adjacent windows carrying the identical chord are
- * merged into one segment; windows with no notes produce no segment, so
- * `at(beat)` returns null there. Each segment carries a confidence in [0, 1]:
- * the fraction of the window weight explained by chord tones, reduced when the
- * match is inexact, and duration-weighted across merged windows.
- *
- * Notes with a zero or negative duration never sound, so they are dropped at
- * ingest: they contribute to neither the key inference, the span, nor any
- * window's histogram.
- *
- * @param notes The notes to analyze (any number of tracks, flattened).
- * @param opts Analysis options; see {@link ChordTimelineOptions}.
- * @returns The inferred timeline, the key used, and per-segment confidences.
- * @throws If `harmonicRhythm` is not positive.
- * @example
- * ```ts
- * import { chordTimelineFromNotes } from '@libraz/libcantus';
- * const notes = [
- *   { pitch: 60, startBeat: 0, durationBeat: 2 }, // C
- *   { pitch: 64, startBeat: 0, durationBeat: 2 }, // E
- *   { pitch: 67, startBeat: 0, durationBeat: 2 }, // G
- * ];
- * const { timeline, key } = chordTimelineFromNotes(notes);
- * timeline.at(0); // the chord inferred over beat 0, or null
- * ```
- * @category Arrangement & Analysis
- */
-declare function chordTimelineFromNotes(notes: NoteEvent[], opts?: ChordTimelineOptions): ChordTimelineResult;
-/**
- * A cadence found between two consecutive timeline segments.
- *
- * @category Arrangement & Analysis
- */
-type CadenceHit = {
-    /** The beat where the cadence arrives (the second chord's onset). */
-    atBeat: number;
-    type: Exclude<Cadence, null>;
-    from: Chord;
-    to: Chord;
-};
-/**
- * Find cadences between consecutive segments of a chord timeline.
- *
- * Each temporally adjacent segment pair is classified with
- * {@link detectCadence}; pairs forming no cadence are skipped. Segments
- * separated by a gap (a rest in the timeline) are not a chord-to-chord
- * progression, so they are never paired.
- *
- * @param timeline The chord timeline to scan.
- * @param key The prevailing key.
- * @returns The cadences found, in time order.
- * @example
- * ```ts
- * import { chordTimelineFromNotes, detectCadences } from '@libraz/libcantus';
- * const notes = [
- *   { pitch: 67, startBeat: 0, durationBeat: 4 }, // G, a dominant
- *   { pitch: 60, startBeat: 4, durationBeat: 4 }, // C, the tonic
- * ];
- * const { timeline, key } = chordTimelineFromNotes(notes);
- * const cadences = detectCadences(timeline, key);
- * ```
- * @category Arrangement & Analysis
- */
-declare function detectCadences(timeline: ChordTimeline, key: KeyScale): CadenceHit[];
-
-export { type CadenceHit as C, type ChordTimeline as a, type ChordTimelineOptions as b, type ChordTimelineResult as c, chordTimelineFromChords as d, chordTimelineFromNotes as e, detectCadences as f };

package/dist/index-BtXT6UQ0.d.cts

@@ -1,192 +0,0 @@
-import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.cjs';
-import { a as ChordQuality, C as Chord } from './index-y_ak9_Hi.cjs';
-
-/**
- * Recognition: infer a chord name from a set of pitches, or a key from a set of
- * pitch classes. This is the inverse direction of the chord/scale builders,
- * which only go name -> notes.
- */
-
-/**
- * A candidate chord interpretation of a pitch set.
- *
- * @category Recognition
- */
-type ChordMatch = {
-    rootPc: number;
-    quality: ChordQuality;
-    /** Chord tones absent from the input (an incomplete voicing). */
-    missingPcs: number[];
-    /** Input pitch classes not belonging to the chord. */
-    extraPcs: number[];
-    /** True when the input pitch-class set equals the chord exactly. */
-    exact: boolean;
-    /**
-     * Inversion implied by a known bass: 0 for root position, 1..n for an
-     * inversion. Null when no inversion can be named — either the input is an
-     * unordered pitch-class set with no bass, or the bass is not a chord tone (a
-     * pedal or passing bass), in which case `bassPc` still reports it.
-     */
-    inversion: number | null;
-    /** Bass pitch class when the lowest note is not the root. */
-    bassPc?: number;
-};
-/**
- * Input interpretation for {@link detectChord} and {@link detectChordBest}.
- *
- * @category Recognition
- */
-type DetectChordOptions = {
-    /**
-     * `midi` uses the numerically lowest pitch as bass; `pitchClass` treats the
-     * input as unordered. `auto` (default) selects pitch-class mode only when all
-     * values lie in 0..11.
-     */
-    input?: 'auto' | 'midi' | 'pitchClass';
-    /** Explicit bass pitch class, including for an unordered pitch-class set. */
-    bassPc?: number;
-};
-/**
- * A candidate key interpretation of a pitch-class set.
- *
- * @category Recognition
- */
-type KeyMatch = {
-    /** The scale that scored best for this tonic and mode, `variant` included. */
-    key: KeyScale;
-    mode: 'major' | 'minor';
-    /** Which scale form `key` uses; minor keys pick the best-scoring of the three. */
-    variant: KeyVariant;
-    /**
-     * Fraction of the distinct input pitch classes that belong to `key`, in
-     * [0, 1]. Measured against the returned scale, so it always agrees with
-     * `isScaleTone(pc, match.key)`. This is a coverage figure, not the ranking:
-     * see `score`.
-     */
-    fit: number;
-    /**
-     * The value the results are ranked by, in [0, 1.5]. Unlike `fit` it counts
-     * every occurrence rather than every distinct pitch class, so a repeated tone
-     * weighs more, and it adds half a count per sounding of the tonic itself to
-     * break ties between keys that contain the same notes.
-     */
-    score: number;
-};
-/**
- * Which form of a scale a {@link KeyMatch} settled on.
- *
- * @category Recognition
- */
-type KeyVariant = 'major' | 'natural' | 'harmonic' | 'melodic';
-/**
- * Input weighting for {@link detectKey}.
- *
- * @category Recognition
- */
-type DetectKeyOptions = {
-    /**
-     * How much each pitch counts toward the histogram, one entry per pitch.
-     * Defaults to one per pitch, which weighs a thirty-second-note ornament as
-     * heavily as the whole note under it. {@link detectKeyFromNotes} supplies
-     * duration times velocity, matching how chord inference weighs its own
-     * histogram.
-     */
-    weights?: readonly number[];
-};
-/**
- * Identify chords matching a set of pitches.
- *
- * Every input pitch class is tried as a root against every known chord quality.
- * A match is reported when all of the chord's tones are present in the input, or
- * when the only absent tone is the perfect fifth (a common omission in shell
- * voicings); matches are ranked best-first by fewest extra notes, then fewest
- * missing notes, then most specific (largest) chord. An exact match (no extras,
- * no missing) is flagged and ranked first.
- *
- * @param pitches MIDI pitches or bare pitch classes (octave-agnostic).
- * @returns Ranked chord interpretations (may be empty).
- * @example
- * ```ts
- * import { detectChord } from '@libraz/libcantus';
- * const matches = detectChord([60, 64, 67]); // C E G
- * matches[0]; // { rootPc: 0, quality: 'maj', exact: true, ... }
- * ```
- * @category Recognition
- */
-declare function detectChord(pitches: readonly number[], opts?: DetectChordOptions): ChordMatch[];
-/**
- * The single best chord interpretation of a pitch set, or null if none.
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @returns The top-ranked chord, or null when nothing matches.
- * @example
- * ```ts
- * import { detectChordBest } from '@libraz/libcantus';
- * detectChordBest([60, 64, 67]); // C major triad: { rootPc: 0, quality: 'maj', ... }
- * ```
- * @category Recognition
- */
-declare function detectChordBest(pitches: readonly number[], opts?: DetectChordOptions): Chord | null;
-/**
- * Rank major and minor keys by how well they contain a set of pitch classes.
- *
- * Ranking is by `score`, which counts repetitions and adds a tonic weight so
- * that, among equally-fitting keys, the one whose root is actually sounded is
- * preferred. Minor candidates are scored against the natural, harmonic, and
- * melodic minor variants and keep the best of the three, so a minor cadence
- * containing the leading tone still resolves to its own tonic; the winning
- * variant is what `key` and `variant` report, so `fit` describes the scale the
- * caller receives. Returns all 24 keys ranked best-first, or an empty array for
- * an empty input (mirroring {@link detectChord}).
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @returns Ranked key interpretations (empty for an empty input).
- * @example
- * ```ts
- * import { detectKey } from '@libraz/libcantus';
- * const keys = detectKey([60, 62, 64, 65, 67, 69, 71]); // C major scale
- * keys[0].mode; // 'major', with keys[0].key.rootPc === 0
- * ```
- * @category Recognition
- */
-declare function detectKey(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch[];
-/**
- * Rank keys by how well they contain a set of note events, weighting each note
- * by how much of the music it actually occupies.
- *
- * {@link detectKey} counts every pitch once, which lets a run of fast ornamental
- * notes outvote the sustained harmony that establishes the key. This weighs
- * each note by duration times velocity, the same measure chord inference uses,
- * so the two agree on what the music emphasises. Notes that never sound (zero
- * or negative duration) are ignored.
- *
- * @param notes The note events to weigh.
- * @returns Ranked key interpretations (empty when nothing sounds).
- * @example
- * ```ts
- * import { detectKeyFromNotes } from '@libraz/libcantus';
- * detectKeyFromNotes([{ pitch: 60, startBeat: 0, durationBeat: 4 }])[0]?.key.rootPc; // 0
- * ```
- * @category Recognition
- */
-declare function detectKeyFromNotes(notes: readonly NoteEvent[]): KeyMatch[];
-/**
- * The single best key interpretation of a pitch set.
- *
- * The counterpart of {@link detectChordBest}: the ranked list is the general
- * answer, but a caller that just wants "what key is this" should not have to
- * index into it and assert the result is there.
- *
- * @param pitches MIDI pitches or bare pitch classes.
- * @param opts How to weigh the input; see {@link DetectKeyOptions}.
- * @returns The top-ranked key, or null when nothing sounds.
- * @example
- * ```ts
- * import { detectKeyBest } from '@libraz/libcantus';
- * detectKeyBest([0, 2, 4, 5, 7, 9, 11])?.mode; // 'major'
- * ```
- * @category Recognition
- */
-declare function detectKeyBest(pitches: readonly number[], opts?: DetectKeyOptions): KeyMatch | null;
-
-export { type ChordMatch as C, type DetectChordOptions as D, type KeyMatch as K, type DetectKeyOptions as a, type KeyVariant as b, detectChordBest as c, detectChord as d, detectKey as e, detectKeyBest as f, detectKeyFromNotes as g };

package/dist/index-C5UBbQ4G.d.ts

@@ -1,152 +0,0 @@
-import { T as TimeSignature } from './index-DXd9JikN.js';
-import { K as KeyScale, N as NoteEvent } from './types-BN6_Q9Kl.js';
-import { C as Chord, b as ChordSegment, c as ChordSpan } from './index-C83mZI1P.js';
-import { C as Cadence } from './function-BtiZb9i9.js';
-
-/**
- * A beat-indexed sequence of chord segments.
- *
- * @category Arrangement & Analysis
- */
-type ChordTimeline = {
-    /** The chord sounding at a beat, or null when no segment covers it. */
-    at: (beat: number) => Chord | null;
-    segments: ChordSegment[];
-};
-/**
- * Build a chord timeline from placed chords.
- *
- * Each chord spans from its `startBeat` to the next chord's `startBeat`; the last
- * chord runs to `totalBeats`. Segments with no positive length (from duplicate
- * onsets or a last chord at or past `totalBeats`) are dropped. `at(beat)` returns
- * the covering segment's chord, or null when the beat lies outside every segment.
- *
- * @param chords Placed chords in time order.
- * @param totalBeats End of the timeline in beats.
- * @returns A queryable chord timeline.
- * @category Arrangement & Analysis
- */
-declare function chordTimelineFromChords(chords: readonly ChordSpan[], totalBeats: number): ChordTimeline;
-/**
- * Options controlling {@link chordTimelineFromNotes}.
- *
- * @category Arrangement & Analysis
- */
-type ChordTimelineOptions = {
-    /** Key context; inferred from the notes with {@link detectKeyFromNotes} when omitted. */
-    key?: KeyScale;
-    /**
-     * Time signature used for metric accents; defaults to 4/4.
-     *
-     * @defaultValue `4/4`
-     */
-    ts?: TimeSignature;
-    /**
-     * Window length in beats per chord slot; defaults to one bar of `ts`.
-     *
-     * @defaultValue one bar of `ts`
-     */
-    harmonicRhythm?: number;
-    /**
-     * End of the analyzed span in beats; defaults to the end of the last note.
-     *
-     * @defaultValue the end of the last note
-     */
-    totalBeats?: number;
-    /**
-     * Upper bound on the work this call may do — note counts, windows, and
-     * candidate counts are each checked against it before anything is allocated.
-     *
-     * Raise it to analyse a piece larger than the default allows; the default is
-     * {@link DEFAULT_GENERATION_BUDGET}, chosen so a runaway input fails fast
-     * rather than blocking the thread.
-     *
-     * @defaultValue {@link DEFAULT_GENERATION_BUDGET}
-     */
-    budget?: number;
-};
-/**
- * The result of {@link chordTimelineFromNotes}.
- *
- * @category Arrangement & Analysis
- */
-type ChordTimelineResult = {
-    /** The inferred timeline, with adjacent identical chords merged. */
-    timeline: ChordTimeline;
-    /** The key used for the analysis (given or inferred). */
-    key: KeyScale;
-    /** One confidence value in [0, 1] per segment, in segment order. */
-    segmentConfidence: number[];
-};
-/**
- * Infer a chord timeline from raw multi-track notes.
- *
- * The span `[0, totalBeats)` is sliced into `harmonicRhythm`-beat windows; each
- * window's chord is inferred from a pitch-class weight histogram of the notes
- * overlapping it (weight = overlap duration x velocity x metric-accent bonus
- * for onsets in the window). Adjacent windows carrying the identical chord are
- * merged into one segment; windows with no notes produce no segment, so
- * `at(beat)` returns null there. Each segment carries a confidence in [0, 1]:
- * the fraction of the window weight explained by chord tones, reduced when the
- * match is inexact, and duration-weighted across merged windows.
- *
- * Notes with a zero or negative duration never sound, so they are dropped at
- * ingest: they contribute to neither the key inference, the span, nor any
- * window's histogram.
- *
- * @param notes The notes to analyze (any number of tracks, flattened).
- * @param opts Analysis options; see {@link ChordTimelineOptions}.
- * @returns The inferred timeline, the key used, and per-segment confidences.
- * @throws If `harmonicRhythm` is not positive.
- * @example
- * ```ts
- * import { chordTimelineFromNotes } from '@libraz/libcantus';
- * const notes = [
- *   { pitch: 60, startBeat: 0, durationBeat: 2 }, // C
- *   { pitch: 64, startBeat: 0, durationBeat: 2 }, // E
- *   { pitch: 67, startBeat: 0, durationBeat: 2 }, // G
- * ];
- * const { timeline, key } = chordTimelineFromNotes(notes);
- * timeline.at(0); // the chord inferred over beat 0, or null
- * ```
- * @category Arrangement & Analysis
- */
-declare function chordTimelineFromNotes(notes: NoteEvent[], opts?: ChordTimelineOptions): ChordTimelineResult;
-/**
- * A cadence found between two consecutive timeline segments.
- *
- * @category Arrangement & Analysis
- */
-type CadenceHit = {
-    /** The beat where the cadence arrives (the second chord's onset). */
-    atBeat: number;
-    type: Exclude<Cadence, null>;
-    from: Chord;
-    to: Chord;
-};
-/**
- * Find cadences between consecutive segments of a chord timeline.
- *
- * Each temporally adjacent segment pair is classified with
- * {@link detectCadence}; pairs forming no cadence are skipped. Segments
- * separated by a gap (a rest in the timeline) are not a chord-to-chord
- * progression, so they are never paired.
- *
- * @param timeline The chord timeline to scan.
- * @param key The prevailing key.
- * @returns The cadences found, in time order.
- * @example
- * ```ts
- * import { chordTimelineFromNotes, detectCadences } from '@libraz/libcantus';
- * const notes = [
- *   { pitch: 67, startBeat: 0, durationBeat: 4 }, // G, a dominant
- *   { pitch: 60, startBeat: 4, durationBeat: 4 }, // C, the tonic
- * ];
- * const { timeline, key } = chordTimelineFromNotes(notes);
- * const cadences = detectCadences(timeline, key);
- * ```
- * @category Arrangement & Analysis
- */
-declare function detectCadences(timeline: ChordTimeline, key: KeyScale): CadenceHit[];
-
-export { type CadenceHit as C, type ChordTimeline as a, type ChordTimelineOptions as b, type ChordTimelineResult as c, chordTimelineFromChords as d, chordTimelineFromNotes as e, detectCadences as f };