interface Data<T> {
    rule: Rule<T>;
    stop: () => void;
    logger: Logger;
}
interface Rule<T> {
    id: string | number;
    name?: string;
    weight?: number;
    condition: (fact: T, data: Data<T>) => Promise<boolean> | boolean;
    action: (fact: T, data: Data<T>) => Promise<void> | void;
}
interface Logger {
    info: (message?: unknown, ...optionalParams: unknown[]) => void;
    warn: (message?: unknown, ...optionalParams: unknown[]) => void;
    error: (message?: unknown, ...optionalParams: unknown[]) => void;
}
interface RuleEngineOptions {
    ignoreFactChanges?: boolean;
    maxIterations?: number;
    logger?: Logger;
}
declare class RuleEngine<T> {
    private rules;
    private rulesDirty;
    private readonly fact;
    private readonly ignoreFactChanges;
    private iteration;
    private readonly maxIterations;
    private terminate;
    private running;
    private readonly logger;
    constructor(fact?: T, options?: RuleEngineOptions);
    addRule(rule: Rule<T>): void;
    addRules(rules: Rule<T>[]): void;
    updateRule(id: string | number, newRule: Rule<T>): boolean;
    removeRule(id: string | number): void;
    stop(): void;
    sort(): void;
    run(): Promise<void>;
    private runPass;
    private evaluateRule;
    private executeRule;
}

export { RuleEngine };
export type { Data, Logger, Rule, RuleEngineOptions };
//# sourceMappingURL=index.d.mts.map