/**
 * Decision Engine
 *
 * The central evaluation engine for DecisionStrategy objects.
 * Routes strategies to their appropriate evaluators.
 */
import type { RuntimeContext } from '../context/types';
import type { EventBus } from '../events/EventBus';
import type { SessionMetricTracker } from '../metrics/sessionMetrics';
import type { StateStore } from '../state/StateStore';
import type { DecisionResult, DecisionStrategy } from './types';
/**
 * Options for the decision engine evaluate function.
 */
export interface EvaluateOptions {
    /** State store for dismissal/cooldown/frequency checks */
    state?: StateStore;
    /** Event bus for event_occurred checks */
    events?: EventBus;
    /** Session metric tracker for session_metric checks */
    sessionMetrics?: SessionMetricTracker;
    /** Event accumulator for event_count conditions */
    accumulator?: {
        getCount(key: string, withinMs?: number): number;
    };
}
/**
 * Evaluate a DecisionStrategy against the current context.
 *
 * @param strategy - The decision strategy to evaluate
 * @param context - The runtime context
 * @param options - Additional evaluation options
 * @returns The decision result
 */
export declare function evaluate<T>(strategy: DecisionStrategy<T>, context: RuntimeContext, options?: EvaluateOptions): Promise<DecisionResult<T>>;
/**
 * Synchronous version of evaluate for simple strategies.
 * Use this when you know the strategy doesn't require async operations.
 */
export declare function evaluateSync<T>(strategy: DecisionStrategy<T>, context: RuntimeContext, options?: EvaluateOptions): DecisionResult<T>;
/**
 * Create a decision engine with pre-bound options.
 */
export declare function createDecisionEngine(options: EvaluateOptions): {
    evaluate: <T>(strategy: DecisionStrategy<T>, context: RuntimeContext) => Promise<DecisionResult<T>>;
    evaluateSync: <T>(strategy: DecisionStrategy<T>, context: RuntimeContext) => DecisionResult<T>;
};
