import { ECSContext } from "../core/ecs";
import { ActionDefinition, ActionInput, ActionTraceNode } from "./action";
import { ConditionDefinition, ConditionTraceNode } from "./condition";
import { RuleTriggerType } from "./ruleContextContracts";
export type EngineTriggerType = Extract<RuleTriggerType, "interact" | "collisionEnter" | "entityInRange" | "timeElapsed" | "die" | "primaryAction" | "secondaryAction">;
export type RuleTrigger = {
    type: 'immediate';
    params?: Record<string, never>;
} | {
    type: 'event';
    params: {
        event: string;
    };
} | {
    type: 'interact' | 'collisionEnter' | 'die';
    params?: Record<string, never>;
} | {
    type: 'timeElapsed';
    params: {
        delay: number;
        repeat?: boolean;
    };
} | {
    type: 'primaryAction' | 'secondaryAction' | 'entityInRange';
    params?: {
        range?: number;
    };
} | {
    type: 'time';
    params: {
        delay: number;
        repeat?: boolean;
    };
} | {
    type: 'interval';
    params: {
        interval: number;
        initialDelay?: number;
        maxCount?: number;
    };
} | {
    type: 'proximity';
    params: {
        position: {
            x: number;
            y: number;
            z: number;
        };
        radius: number;
        once?: boolean;
    };
};
export type RuleDefinition = {
    trigger: RuleTrigger;
    condition?: ConditionDefinition;
    priority?: number;
    actions: ActionInput;
    cooldown?: number;
    enabled?: boolean;
    __cooldownRemaining?: number;
};
type CanonicalRuleDefinition = Omit<RuleDefinition, "actions"> & {
    actions: ActionDefinition;
};
export type RuleContext = {
    self: number;
    other?: number;
    user?: number;
};
export type RuleTraceReason = "rule_disabled" | "cooldown_active" | "condition_false" | "no_actions_defined" | "target_unavailable_for_trigger" | "missing_context_value" | "action_applied" | "action_failed" | "actions_skipped";
export type RuleOperationTrace = {
    index: number;
    type: string;
    target: string;
    executed: boolean;
    success: boolean;
    reason: RuleTraceReason;
    path?: string;
    message?: string;
};
export type RuleExecutionTrace = {
    timestamp: number;
    ruleName: string;
    owner: number;
    trigger: RuleTrigger["type"];
    context: RuleContext;
    conditionPassed?: boolean;
    conditionTrace?: ConditionTraceNode;
    actionTrace?: ActionTraceNode;
    reason: RuleTraceReason;
    fired: boolean;
    operations: RuleOperationTrace[];
    /**
     * @deprecated Legacy alias maintained for trace consumers that still read `effects`.
     */
    effects?: RuleOperationTrace[];
};
export type RuleTraceCallback = (trace: RuleExecutionTrace) => void;
export declare class RuleModule {
    private readonly ctx;
    private readonly definitionsByName;
    private readonly globalEventIndex;
    private readonly engineTriggerIndex;
    private readonly stateByName;
    private readonly ownerByRule;
    private readonly registrationIndexByRule;
    private readonly globalEventQueue;
    private nextRegistrationIndex;
    constructor(ctx: ECSContext);
    private normalizeRuleDefinition;
    registerEntityRule(name: string, ownerEid: number, def: RuleDefinition): CanonicalRuleDefinition;
    emitEngineTrigger(triggerType: EngineTriggerType, context: RuleContext): number;
    emitGlobalEvent(name: string, payload?: any): void;
    update(deltaTime: number): void;
    private drainGlobalEvents;
    removeEntityRules(eid: number): void;
    replaceEntityRules(eid: number, rules: RuleDefinition[]): void;
    getEntityRules(eid: number): RuleDefinition[];
    hasRuleForEntity(eid: number): boolean;
    hasEngineTriggerForEntity(eid: number, triggerType: EngineTriggerType): boolean;
    getEntityRulesByTrigger(eid: number, triggerType: EngineTriggerType): RuleDefinition[];
    getEntityRulesForSerialization(eid: number): RuleDefinition[];
    getEntityMaxCooldownPercent(eid: number): number | null;
    private isTraceEnabled;
    private emitTrace;
    private evaluateConditionDefinition;
    private toRuleOperationTrace;
    private executeRule;
    hasDefinition(name: string): boolean;
    private getRulePriority;
    private getRuleRegistrationIndex;
    private compareRuleNames;
    private getSortedRuleNames;
    private getNow;
}
export declare const ruleModule: (ctx: ECSContext) => RuleModule;
export declare function getRuleModule(ctx: ECSContext): RuleModule;
export {};
//# sourceMappingURL=rule.d.ts.map