/**
 * Exponential moving average of mastery contributions. Provides a per-
 * decision-point and a global aggregate score, both centred at 0:
 *
 *   `score === 0` → on average, evaluators returned 1.0 (neutral)
 *   `score > 0`   → trending bonus (player is consistently timing well)
 *   `score < 0`   → trending penalty (player is consistently mistiming)
 *
 * The controller does NOT consume this score itself. It's a side-channel
 * for downstream systems (HUDs, post-match summaries, training-mode
 * coaching, achievement triggers, leaderboards) to expose mastery
 * progress however they see fit, without forcing any visual treatment on
 * the controller.
 *
 * Samples are added by {@link MasterySet} as evaluators fire. Time-based
 * decay (so old samples wash out) is applied via {@link tick}.
 *
 * @author Alex Goldring
 * @copyright Company Named Limited (c) 2026
 */
export class MasteryScore {
    /**
     * @param {number} [halfLife] seconds for any sample's contribution to halve
     */
    constructor(halfLife?: number);
    /**
     * Time-half-life of the EMA. A score sample 1×halfLife ago counts ½
     * as much as a fresh one. Tune for "how recent should mastery feel".
     * @type {number}
     */
    halfLife: number;
    /**
     * EMA of (multiplier − 1.0) across ALL evaluator contributions.
     * Useful as a single-number "how skilled has the player been
     * recently" indicator.
     * @type {number}
     */
    aggregate: number;
    /**
     * EMA per decision point — same metric, sliced by which interaction
     * the contribution came from. Index space matches DecisionPoint.
     * Useful for telemetry like "you're nailing jump timing but poor at
     * slide initiation".
     * @type {number[]}
     */
    byPoint: number[];
    /**
     * Record a contribution from an evaluator. Call once per evaluator per
     * decision-point evaluation. The multiplier is converted to a signed
     * deviation from neutral (1.0) for EMA accumulation.
     *
     * @param {number} decisionPoint
     * @param {number} multiplier  raw evaluator output (1.0 = neutral)
     */
    record(decisionPoint: number, multiplier: number): void;
    /**
     * Apply time-based decay so stale samples wash out. Call once per
     * fixed step; the system handles this for you.
     *
     * @param {number} dt seconds
     */
    decay(dt: number): void;
    /**
     * Reset to neutral. Useful on respawn / scene change.
     */
    reset(): void;
}
//# sourceMappingURL=MasteryScore.d.ts.map