import { Observable } from 'rxjs';
import type { RulesEngine } from '../engine';
import { DebugEvent, EvaluationReason, RuleEvaluation, RuleEvaluationOutput } from '../engine.interface';
import type { Facts } from '../fact';
import { RulesetExecutor } from '../ruleset-executor';
import type { ActionBlock, Ruleset } from '../structure';
export interface EngineDebuggerOptions {
    /**
     * Limit of events to keep in the stack before subscribing to the debugEvents$ stream.
     * @default undefined no limit
     */
    eventsStackLimit?: number;
}
/**
 * Rules engine debugger object to emit debug events
 */
export declare class EngineDebugger {
    private registeredRuleEngine?;
    private registeredRulesets;
    private readonly debugEventsSubject$;
    private performanceMeasures$;
    /** Stream emitting a debug event when is fired; timeline is kept */
    readonly debugEvents$: Observable<DebugEvent>;
    /** Retrieved the rules engine plugged to the debugger */
    get rulesEngine(): RulesEngine | undefined;
    /**
     * Instantiate a rules engine debugger
     * @param options Options to configure the debugger
     */
    constructor(options?: EngineDebuggerOptions);
    private initializePerformanceObserver;
    private createBaseExecutionOutputObject;
    private rulesetExecution;
    private rulesetExecutionError;
    /**
     * Plug the debugger to a Rule Engine
     * @param rulesEngine
     */
    registerRuleEngine(rulesEngine: RulesEngine): void;
    /**
     * Handle ruleset execution debug info
     * @param currRes
     * @param prevRes
     * @param allExecutionsValid
     * @param rulesetInputFacts
     * @param runtimeFactValues
     * @param executionCounter
     * @param ruleset
     */
    handleDebugRulesetExecutionInfo(currRes: RuleEvaluationOutput[], prevRes: RuleEvaluationOutput[] | undefined, allExecutionsValid: boolean, rulesetInputFacts: string[], runtimeFactValues: Record<string, Facts>, executionCounter: number, ruleset: Ruleset): {
        executionCounter: number;
        rulesetOutputExecution: RuleEvaluation[];
        allExecutionsValid: boolean;
        rulesetTriggers: Record<string, Record<string, EvaluationReason>>;
    };
    /**
     * Emits an 'AvailableRulesets' debug event when rulesets are registered to the rules engine
     * @param rulesets
     */
    addAvailableRulesets(rulesets: Ruleset[]): void;
    /**
     * Computes and emits an 'ActiveRulesets' debug event when the active rulesets are changing
     * @param ruleSetExecutorMap map off all rulesets executors
     * @param restrictiveRuleSets ids of the rulesets to activate; if not provided all registered rulesets will be considered as active
     */
    activeRulesetsChange(ruleSetExecutorMap: Record<string, RulesetExecutor>, restrictiveRuleSets?: string[]): void;
    /**
     * Emits an 'AllActions' debug event each time the rules engine outputs the list of actions
     * @param actions list of outputted actions
     */
    allActionsChange(actions: ActionBlock[]): void;
    /**
     * Emits a 'RulesetExecution' debug event at the output of a successful ruleset execution
     * @param ruleset
     * @param executionCounter
     * @param rulesetInputFacts
     * @param allOutputActions
     * @param runtimeFactValues
     * @param rulesetTriggers
     * @param rulesExecutions
     */
    addRulesetExecutionEvent(ruleset: Ruleset, executionCounter: number, rulesetInputFacts: string[], allOutputActions: ActionBlock[], runtimeFactValues: Record<string, Facts>, rulesetTriggers: Record<string, Record<string, EvaluationReason>>, rulesExecutions: RuleEvaluation[]): void;
    /**
     * Emits a 'RulesetExecutionError' debug event at the output of a failing ruleset execution
     * @param ruleset
     * @param rulesetInputFacts
     * @param executionCounter
     * @param runtimeFactValues
     * @param rulesetTriggers
     * @param rulesExecutions
     */
    addRulesetExecutionErrorEvent(ruleset: Ruleset, rulesetInputFacts: string[], executionCounter: number, runtimeFactValues: Record<string, Facts>, rulesetTriggers: Record<string, Record<string, EvaluationReason>>, rulesExecutions: RuleEvaluation[]): void;
    /**
     * Emits a 'AvailableFactsSnapshot' debug event when a fact value is updated
     * @param _id
     * @param factValue$
     */
    addAvailableFactsSnapshotEvent(_id: string, factValue$: Observable<any>): void;
    /**
     * Returns a list of fact name and value pairs
     * @param factsNames List of facts names to get the value for
     */
    getFactsSnapshot(factsNames: string[]): Promise<{
        factName: string;
        value: any;
    }[]>;
}
//# sourceMappingURL=engine.debug.d.ts.map