import { PlayerContext, Event } from '../types';
import { IRuleEngine } from '../interfaces';
export interface RuleCondition {
    type: string;
    params: {
        [key: string]: any;
    };
}
export interface RuleEffects {
    addTags?: string[];
    modifyTitle?: {
        append?: string;
        prepend?: string;
        replace?: string;
    };
    modifyDescription?: {
        append?: string;
        prepend?: string;
        replace?: string;
    };
    adjustEffects?: {
        [key: string]: number;
    };
    modifyDifficulty?: string;
    setUrgency?: number;
    addContext?: {
        [key: string]: any;
    };
}
export interface RuleDefinition {
    id?: string;
    conditions: RuleCondition[];
    effects: RuleEffects;
    priority?: number;
    enabled?: boolean;
    name?: string;
    description?: string;
}
export interface RuleValidationResult {
    valid: boolean;
    errors: string[];
}
export declare class RuleEngine implements IRuleEngine {
    private rules;
    private conditionEvaluators;
    private effectApplicators;
    private ruleDefinitions;
    constructor();
    /**
     * Initialize built-in condition evaluators
     */
    private initializeConditionEvaluators;
    /**
     * Initialize built-in effect applicators
     */
    private initializeEffectApplicators;
    registerRule(ruleOrId: string | RuleDefinition, rule?: RuleDefinition): boolean;
    getRule(id: string): RuleDefinition | null;
    getAllRules(): RuleDefinition[];
    unregisterRule(id: string): boolean;
    getRuleCount(): number;
    clearAllRules(): void;
    /**
     * Evaluate a single condition (overloaded for test compatibility)
     */
    evaluateCondition(conditionOrContext: any, contextOrCondition?: any): boolean;
    /**
     * Evaluate multiple conditions with AND/OR logic
     */
    evaluateConditions(conditions: RuleCondition[], logic: 'AND' | 'OR', context: PlayerContext): boolean;
    /**
     * Evaluate rules and apply effects to event
     */
    evaluateRules(event: Event, context: PlayerContext): boolean;
    /**
     * Apply a single effect to an event
     */
    applyEffect(effect: any, event: Event): void;
    /**
     * Evaluate a single condition (original method signature)
     */
    /**
     * Evaluate all conditions in a rule
     */
    evaluateRule(context: PlayerContext, rule: RuleDefinition): boolean;
    /**
     * Apply rule effects to an event
     */
    applyRuleEffects(event: Event, rule: RuleDefinition, context: PlayerContext): Event;
    /**
     * Add a custom rule
     */
    addRule(name: string, rule: RuleDefinition): void;
    /**
     * Remove a custom rule
     */
    removeRule(name: string): boolean;
    /**
     * Get all custom rules
     */
    getRules(): {
        [name: string]: RuleDefinition;
    };
    /**
     * Clear all custom rules
     */
    clearRules(): void;
    /**
     * Validate a rule definition
     */
    validateRule(rule: RuleDefinition): RuleValidationResult;
    /**
     * Add a custom condition evaluator
     */
    addConditionEvaluator(type: string, evaluator: Function): void;
    /**
     * Add a custom effect applicator
     */
    addEffectApplicator(type: string, applicator: Function): void;
    /**
     * Get nested value from object using dot notation
     */
    private getNestedValue;
    /**
     * Process an event through all applicable rules
     */
    processEvent(event: Event, context: PlayerContext): Event;
    /**
     * Get rule engine statistics
     */
    getStats(): {
        totalRules: number;
        conditionTypes: number;
        effectTypes: number;
    };
}
//# sourceMappingURL=RuleEngine.d.ts.map