import { ECSContext } from "../core/ecs";
import { MetricsKey } from "../core/metrics";
import { Module } from "./Module";
export declare const CONDITION_TYPE_OPTIONS: readonly ["always", "compare", "reference", "not", "all", "any"];
export type ConditionType = typeof CONDITION_TYPE_OPTIONS[number];
export declare const VALUE_EXPRESSION_TYPE_OPTIONS: readonly ["literal", "parameter", "metric", "store", "component", "query", "sum"];
export type ValueExpressionType = typeof VALUE_EXPRESSION_TYPE_OPTIONS[number];
export declare const CONDITION_COMPARE_OPERATOR_OPTIONS: readonly ["eq", "neq", "gt", "gte", "lt", "lte"];
export type ConditionCompareOperator = typeof CONDITION_COMPARE_OPERATOR_OPTIONS[number];
export type ConditionSubjectRef = MetricsKey | "self" | "other" | "user";
export type ConditionContext = {
    self?: MetricsKey;
    other?: MetricsKey;
    user?: MetricsKey;
};
export type ConditionEvaluationInput = {
    defaultSubject: MetricsKey;
    context?: ConditionContext;
    parameters?: Record<string, unknown>;
    queryContext?: Record<string, unknown>;
};
export type ValueExpression = {
    type: "literal";
    params: {
        value: unknown;
    };
} | {
    type: "parameter";
    params: {
        name: string;
        defaultValue?: unknown;
    };
} | {
    type: "metric";
    params: {
        metric: string;
        subtype?: string;
        subject?: ConditionSubjectRef;
        defaultValue?: number;
    };
} | {
    type: "store";
    params: {
        store: string;
        path?: string;
        subject?: ConditionSubjectRef;
        defaultValue?: unknown;
    };
} | {
    type: "component";
    params: {
        component: string;
        field?: string;
        subject?: ConditionSubjectRef;
        defaultValue?: unknown;
    };
} | {
    type: "query";
    params: {
        query: string;
        params?: Record<string, ValueExpression | unknown>;
        defaultValue?: unknown;
    };
} | {
    type: "sum";
    params: {
        values: ValueExpression[];
    };
};
export type ConditionDefinition = {
    type: "always";
    params: Record<string, never>;
} | {
    type: "compare";
    params: {
        operator: ConditionCompareOperator;
        left: ValueExpression;
        right: ValueExpression;
    };
} | {
    type: "reference";
    params: {
        name: string;
        args?: Record<string, ValueExpression | unknown>;
    };
} | {
    type: "not";
    params: {
        condition: ConditionDefinition;
    };
} | {
    type: "all";
    params: {
        conditions: ConditionDefinition[];
    };
} | {
    type: "any";
    params: {
        conditions: ConditionDefinition[];
    };
};
export type ConditionTraceReason = "always_true" | "comparison_true" | "comparison_false" | "subject_unresolved" | "metric_missing" | "reference_resolved" | "reference_missing" | "reference_depth_exceeded" | "all_true" | "all_false" | "any_true" | "any_false" | "not_true" | "not_false";
export type ConditionTraceNode = {
    type: string;
    passed: boolean;
    reason: ConditionTraceReason;
    details?: Record<string, unknown>;
    children?: ConditionTraceNode[];
};
export type ConditionTraceSource = {
    system: "rule" | "trigger" | "achievement" | "spawner" | "manual";
    name?: string;
    owner?: MetricsKey;
    trigger?: string;
};
export type ConditionEvaluationTrace = {
    timestamp: number;
    source?: ConditionTraceSource;
    input: ConditionEvaluationInput;
    passed: boolean;
    node: ConditionTraceNode;
};
export type ConditionTraceCallback = (trace: ConditionEvaluationTrace) => void;
export type ConditionEvaluationOptions = {
    source?: ConditionTraceSource;
    emitTrace?: boolean;
    maxReferenceDepth?: number;
};
export type ConditionEvaluator = (input: ConditionEvaluationInput) => boolean;
export type ConditionQueryResolver = (params: Record<string, unknown>, input: ConditionEvaluationInput, ctx: ECSContext) => unknown;
type InternalConditionEvaluator = (input: ConditionEvaluationInput, state: ConditionEvaluatorState) => ConditionTraceNode;
type ConditionEvaluatorState = {
    depth: number;
    maxDepth: number;
};
export declare function resolveConditionSubject(ref: ConditionSubjectRef | undefined, input: ConditionEvaluationInput): MetricsKey | undefined;
export declare function normalizeConditionDefinition(definition: unknown): ConditionDefinition;
export declare class ConditionModule extends Module<ConditionDefinition, InternalConditionEvaluator> {
    private readonly queryResolvers;
    constructor(ctx: ECSContext);
    addDefinition(name: string, def: ConditionDefinition, isBuiltIn?: boolean): void;
    resolve(defOrName: string | ConditionDefinition): number;
    register(name: string, def: ConditionDefinition): InternalConditionEvaluator;
    register(name: string, baseName: string, overrides: Partial<ConditionDefinition>): InternalConditionEvaluator;
    registerQuery(name: string, resolver: ConditionQueryResolver): void;
    getQuery(name: string): ConditionQueryResolver | undefined;
    evaluate(definition: ConditionDefinition, input: ConditionEvaluationInput): boolean;
    evaluateWithTrace(definition: ConditionDefinition, input: ConditionEvaluationInput, options?: Pick<ConditionEvaluationOptions, "maxReferenceDepth">): {
        passed: boolean;
        node: ConditionTraceNode;
    };
    private registerBuiltInQueries;
    private compileValueExpression;
    private registerBuiltInConditionTypes;
}
export declare const conditionModule: (ctx: ECSContext) => ConditionModule;
export declare function getConditionModule(ctx: ECSContext): ConditionModule;
export declare function evaluateCondition(ctx: ECSContext, definition: ConditionDefinition, input: ConditionEvaluationInput): boolean;
export declare function evaluateConditionWithTrace(ctx: ECSContext, definition: ConditionDefinition, input: ConditionEvaluationInput, options?: ConditionEvaluationOptions): ConditionEvaluationTrace;
export {};
//# sourceMappingURL=condition.d.ts.map