verdict-rules/dist/engine.d.ts

A small, zero-dependency, async-native rule-evaluation engine. Compose conditions into one explainable pass/fail verdict, with sequential evaluation and real short-circuiting as a guarantee.

import type { RuleResult, RunResult } from "./result.js";
import type { Rule } from "./rule.js";
/**
 * Holds a set of rules and answers questions about them.
 *
 * The engine's run modes never short-circuit; a composite reaches one
 * verdict and stops.
 *
 * Generic over `TContext`, the same way {@link Rule} is, with no default
 * type parameter — dict-context is `RulesEngine<Context>`.
 */
export declare class RulesEngine<TContext> {
    #private;
    constructor(rules: readonly Rule<TContext>[]);
    /** Every rule name registered here, in registration order. */
    get ruleNames(): readonly string[];
    /** Every group label carried by at least one rule, in first-seen order. */
    get groupNames(): readonly string[];
    /** Evaluate every registered rule. Never short-circuits. */
    runAll(context: TContext): Promise<RunResult>;
    /**
     * Evaluate one rule by name, or return `undefined` if no such rule exists.
     *
     * `undefined` means absent, never failed.
     */
    tryRunNamed(name: string, context: TContext): Promise<RuleResult | undefined>;
    /**
     * Evaluate exactly one rule, looked up by name.
     *
     * @throws {UnknownLookupError} if no rule has this name.
     */
    runNamed(name: string, context: TContext): Promise<RuleResult>;
    /**
     * Evaluate a group, or return `undefined` if no such group exists.
     *
     * `undefined` means absent, never vacuously passed.
     */
    tryRunGroup(group: string, context: TContext): Promise<RunResult | undefined>;
    /**
     * Evaluate every rule sharing a group label. Never short-circuits.
     *
     * @throws {UnknownLookupError} if no rule carries this label.
     */
    runGroup(group: string, context: TContext): Promise<RunResult>;
}