@f-o-t/rules-engine 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1312 @@
+import { ArrayCondition, BooleanCondition, Condition as Condition2, ConditionGroup as ConditionGroup6, CustomCondition, DateCondition, EvaluationResult, GroupEvaluationResult as GroupEvaluationResult2, LogicalOperator, NumberCondition, StringCondition } from "@f-o-t/condition-evaluator";
+import { z } from "zod";
+type ConsequenceDefinitions = Record<string, z.ZodType>;
+type DefaultConsequences = Record<string, z.ZodType>;
+type InferConsequenceType<T extends ConsequenceDefinitions> = keyof T;
+type InferConsequencePayload<
+	T extends ConsequenceDefinitions,
+	K extends keyof T
+> = z.infer<T[K]>;
+type Consequence<
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences,
+	TType extends keyof TConsequences = keyof TConsequences
+> = {
+	readonly type: TType;
+	readonly payload: z.infer<TConsequences[TType]>;
+};
+type ConsequenceInput<
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences,
+	TType extends keyof TConsequences = keyof TConsequences
+> = {
+	type: TType;
+	payload: z.infer<TConsequences[TType]>;
+};
+type AggregatedConsequence<TConsequences extends ConsequenceDefinitions = DefaultConsequences> = {
+	readonly type: keyof TConsequences;
+	readonly payload: unknown;
+	readonly ruleId: string;
+	readonly ruleName?: string;
+	readonly priority: number;
+};
+import { ConditionGroup } from "@f-o-t/condition-evaluator";
+import { z as z2 } from "zod";
+type Rule<
+	_TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly id: string;
+	readonly name: string;
+	readonly description?: string;
+	readonly conditions: ConditionGroup;
+	readonly consequences: ReadonlyArray<Consequence<TConsequences>>;
+	readonly priority: number;
+	readonly enabled: boolean;
+	readonly stopOnMatch: boolean;
+	readonly tags: ReadonlyArray<string>;
+	readonly category?: string;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+	readonly createdAt: Date;
+	readonly updatedAt: Date;
+};
+type RuleInput<
+	_TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	id?: string;
+	name: string;
+	description?: string;
+	conditions: ConditionGroup;
+	consequences: Array<{
+		type: keyof TConsequences;
+		payload: z2.infer<TConsequences[keyof TConsequences]>;
+	}>;
+	priority?: number;
+	enabled?: boolean;
+	stopOnMatch?: boolean;
+	tags?: string[];
+	category?: string;
+	metadata?: Record<string, unknown>;
+};
+type RuleSet = {
+	readonly id: string;
+	readonly name: string;
+	readonly description?: string;
+	readonly ruleIds: ReadonlyArray<string>;
+	readonly enabled: boolean;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type RuleSetInput = {
+	id?: string;
+	name: string;
+	description?: string;
+	ruleIds: string[];
+	enabled?: boolean;
+	metadata?: Record<string, unknown>;
+};
+type RuleFilters = {
+	readonly enabled?: boolean;
+	readonly tags?: ReadonlyArray<string>;
+	readonly category?: string;
+	readonly ruleSetId?: string;
+	readonly ids?: ReadonlyArray<string>;
+};
+declare const RuleSchema: z2.ZodObject<{
+	id: z2.ZodString;
+	name: z2.ZodString;
+	description: z2.ZodOptional<z2.ZodString>;
+	conditions: z2.ZodCustom<import("@f-o-t/condition-evaluator").ConditionGroupInput, import("@f-o-t/condition-evaluator").ConditionGroupInput>;
+	consequences: z2.ZodArray<z2.ZodObject<{
+		type: z2.ZodString;
+		payload: z2.ZodUnknown;
+	}, z2.core.$strip>>;
+	priority: z2.ZodDefault<z2.ZodNumber>;
+	enabled: z2.ZodDefault<z2.ZodBoolean>;
+	stopOnMatch: z2.ZodDefault<z2.ZodBoolean>;
+	tags: z2.ZodDefault<z2.ZodArray<z2.ZodString>>;
+	category: z2.ZodOptional<z2.ZodString>;
+	metadata: z2.ZodOptional<z2.ZodRecord<z2.ZodString, z2.ZodUnknown>>;
+	createdAt: z2.ZodDefault<z2.ZodDate>;
+	updatedAt: z2.ZodDefault<z2.ZodDate>;
+}, z2.core.$strip>;
+declare const RuleSetSchema: z2.ZodObject<{
+	id: z2.ZodString;
+	name: z2.ZodString;
+	description: z2.ZodOptional<z2.ZodString>;
+	ruleIds: z2.ZodArray<z2.ZodString>;
+	enabled: z2.ZodDefault<z2.ZodBoolean>;
+	metadata: z2.ZodOptional<z2.ZodRecord<z2.ZodString, z2.ZodUnknown>>;
+}, z2.core.$strip>;
+type RuleSchemaType = z2.infer<typeof RuleSchema>;
+type RuleSetSchemaType = z2.infer<typeof RuleSetSchema>;
+type RuleComplexity = {
+	readonly ruleId: string;
+	readonly ruleName: string;
+	readonly totalConditions: number;
+	readonly maxDepth: number;
+	readonly groupCount: number;
+	readonly uniqueFields: number;
+	readonly uniqueOperators: number;
+	readonly consequenceCount: number;
+	readonly complexityScore: number;
+};
+type RuleSetAnalysis<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly ruleCount: number;
+	readonly enabledCount: number;
+	readonly disabledCount: number;
+	readonly totalConditions: number;
+	readonly totalConsequences: number;
+	readonly uniqueFields: ReadonlyArray<string>;
+	readonly uniqueOperators: ReadonlyArray<string>;
+	readonly uniqueConsequenceTypes: ReadonlyArray<string>;
+	readonly uniqueCategories: ReadonlyArray<string>;
+	readonly uniqueTags: ReadonlyArray<string>;
+	readonly priorityRange: {
+		min: number;
+		max: number;
+	};
+	readonly averageComplexity: number;
+	readonly complexityDistribution: {
+		readonly low: number;
+		readonly medium: number;
+		readonly high: number;
+	};
+	readonly ruleComplexities: ReadonlyArray<RuleComplexity>;
+};
+type FieldUsage = {
+	readonly field: string;
+	readonly count: number;
+	readonly types: ReadonlyArray<string>;
+	readonly operators: ReadonlyArray<string>;
+	readonly rules: ReadonlyArray<{
+		id: string;
+		name: string;
+	}>;
+};
+type OperatorUsage = {
+	readonly operator: string;
+	readonly type: string;
+	readonly count: number;
+	readonly rules: ReadonlyArray<{
+		id: string;
+		name: string;
+	}>;
+};
+type ConsequenceUsage = {
+	readonly type: string;
+	readonly count: number;
+	readonly rules: ReadonlyArray<{
+		id: string;
+		name: string;
+	}>;
+};
+declare const analyzeRuleComplexity: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: Rule<TContext, TConsequences>) => RuleComplexity;
+declare const analyzeRuleSet: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => RuleSetAnalysis<TContext, TConsequences>;
+declare const analyzeFieldUsage: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<FieldUsage>;
+declare const analyzeOperatorUsage: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<OperatorUsage>;
+declare const analyzeConsequenceUsage: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<ConsequenceUsage>;
+declare const findMostComplexRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, limit?: number) => ReadonlyArray<RuleComplexity>;
+declare const findLeastUsedFields: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, limit?: number) => ReadonlyArray<FieldUsage>;
+declare const formatRuleSetAnalysis: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(analysis: RuleSetAnalysis<TContext, TConsequences>) => string;
+import { Condition, ConditionGroup as ConditionGroup2 } from "@f-o-t/condition-evaluator";
+type ConditionBuilderState = {
+	readonly conditions: (Condition | ConditionGroup2)[];
+};
+type ConditionBuilder = {
+	readonly number: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq", value: number) => ConditionBuilder;
+	readonly string: (field: string, operator: "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "in" | "not_in" | "like" | "not_like" | "ilike" | "not_ilike" | "regex" | "not_regex", value: string | string[]) => ConditionBuilder;
+	readonly boolean: (field: string, operator: "eq" | "neq", value: boolean) => ConditionBuilder;
+	readonly date: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq" | "between", value: string | Date | [string | Date, string | Date]) => ConditionBuilder;
+	readonly array: (field: string, operator: "contains" | "not_contains" | "contains_all" | "contains_any" | "is_empty" | "is_not_empty" | "length_eq" | "length_gt" | "length_lt", value: unknown) => ConditionBuilder;
+	readonly ref: (field: string, operator: string, valueRef: string) => ConditionBuilder;
+	readonly and: (builder: (cb: ConditionBuilder) => ConditionBuilder) => ConditionBuilder;
+	readonly or: (builder: (cb: ConditionBuilder) => ConditionBuilder) => ConditionBuilder;
+	readonly raw: (condition: Condition | ConditionGroup2) => ConditionBuilder;
+	readonly build: () => ConditionGroup2;
+	readonly getConditions: () => ReadonlyArray<Condition | ConditionGroup2>;
+};
+declare const resetBuilderIds: () => void;
+declare const conditions: () => ConditionBuilder;
+declare const and: (builderFn: (cb: ConditionBuilder) => ConditionBuilder) => ConditionGroup2;
+declare const or: (builderFn: (cb: ConditionBuilder) => ConditionBuilder) => ConditionGroup2;
+declare const all: (...items: (Condition | ConditionGroup2)[]) => ConditionGroup2;
+declare const any: (...items: (Condition | ConditionGroup2)[]) => ConditionGroup2;
+declare const num: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq", value: number) => Condition;
+declare const str: (field: string, operator: "eq" | "neq" | "contains" | "not_contains" | "starts_with" | "ends_with" | "in" | "not_in" | "like" | "not_like" | "ilike" | "not_ilike" | "regex" | "not_regex", value: string | string[]) => Condition;
+declare const bool: (field: string, operator: "eq" | "neq", value: boolean) => Condition;
+declare const date: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq" | "between", value: string | Date | [string | Date, string | Date]) => Condition;
+declare const arr: (field: string, operator: "contains" | "not_contains" | "contains_all" | "contains_any" | "is_empty" | "is_not_empty" | "length_eq" | "length_gt" | "length_lt", value?: unknown) => Condition;
+import { ConditionGroup as ConditionGroup3 } from "@f-o-t/condition-evaluator";
+import { z as z3 } from "zod";
+type RuleBuilderState<
+	_TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly id?: string;
+	readonly name?: string;
+	readonly description?: string;
+	readonly conditions?: ConditionGroup3;
+	readonly consequences: Array<{
+		type: keyof TConsequences;
+		payload: z3.infer<TConsequences[keyof TConsequences]>;
+	}>;
+	readonly priority: number;
+	readonly enabled: boolean;
+	readonly stopOnMatch: boolean;
+	readonly tags: string[];
+	readonly category?: string;
+	readonly metadata?: Record<string, unknown>;
+};
+type RuleBuilder<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly id: (id: string) => RuleBuilder<TContext, TConsequences>;
+	readonly named: (name: string) => RuleBuilder<TContext, TConsequences>;
+	readonly describedAs: (description: string) => RuleBuilder<TContext, TConsequences>;
+	readonly when: (conditions: ConditionGroup3 | ((cb: ConditionBuilder) => ConditionBuilder)) => RuleBuilder<TContext, TConsequences>;
+	readonly then: <K extends keyof TConsequences>(type: K, payload: z3.infer<TConsequences[K]>) => RuleBuilder<TContext, TConsequences>;
+	readonly withPriority: (priority: number) => RuleBuilder<TContext, TConsequences>;
+	readonly enabled: (enabled?: boolean) => RuleBuilder<TContext, TConsequences>;
+	readonly disabled: () => RuleBuilder<TContext, TConsequences>;
+	readonly stopOnMatch: (stop?: boolean) => RuleBuilder<TContext, TConsequences>;
+	readonly tagged: (...tags: string[]) => RuleBuilder<TContext, TConsequences>;
+	readonly inCategory: (category: string) => RuleBuilder<TContext, TConsequences>;
+	readonly withMetadata: (metadata: Record<string, unknown>) => RuleBuilder<TContext, TConsequences>;
+	readonly build: () => RuleInput<TContext, TConsequences>;
+	readonly getState: () => RuleBuilderState<TContext, TConsequences>;
+};
+declare const rule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>() => RuleBuilder<TContext, TConsequences>;
+declare const createRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(builderFn: (rb: RuleBuilder<TContext, TConsequences>) => RuleBuilder<TContext, TConsequences>) => RuleInput<TContext, TConsequences>;
+type EngineState<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly rules: ReadonlyMap<string, Rule<TContext, TConsequences>>;
+	readonly ruleSets: ReadonlyMap<string, RuleSet>;
+	readonly ruleOrder: ReadonlyArray<string>;
+};
+type MutableEngineState<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	rules: Map<string, Rule<TContext, TConsequences>>;
+	ruleSets: Map<string, RuleSet>;
+	ruleOrder: string[];
+};
+type RuleStats = {
+	readonly evaluations: number;
+	readonly matches: number;
+	readonly errors: number;
+	readonly totalTimeMs: number;
+	readonly avgTimeMs: number;
+	readonly lastEvaluated?: Date;
+};
+type MutableRuleStats = {
+	evaluations: number;
+	matches: number;
+	errors: number;
+	totalTimeMs: number;
+	avgTimeMs: number;
+	lastEvaluated?: Date;
+};
+type OptimizerState = {
+	readonly ruleStats: ReadonlyMap<string, RuleStats>;
+	readonly lastOptimized?: Date;
+};
+type MutableOptimizerState = {
+	ruleStats: Map<string, MutableRuleStats>;
+	lastOptimized?: Date;
+};
+type EngineStats = {
+	readonly totalRules: number;
+	readonly enabledRules: number;
+	readonly disabledRules: number;
+	readonly totalRuleSets: number;
+	readonly totalEvaluations: number;
+	readonly totalMatches: number;
+	readonly totalErrors: number;
+	readonly avgEvaluationTimeMs: number;
+	readonly cacheHits: number;
+	readonly cacheMisses: number;
+	readonly cacheHitRate: number;
+};
+type CacheStats = {
+	readonly size: number;
+	readonly maxSize: number;
+	readonly hits: number;
+	readonly misses: number;
+	readonly hitRate: number;
+	readonly evictions: number;
+};
+declare const createInitialState: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>() => MutableEngineState<TContext, TConsequences>;
+declare const createInitialOptimizerState: () => MutableOptimizerState;
+declare const createInitialRuleStats: () => MutableRuleStats;
+type CacheEntry<T> = {
+	value: T;
+	expiresAt: number;
+	createdAt: number;
+};
+type Cache<T> = {
+	readonly get: (key: string) => T | undefined;
+	readonly set: (key: string, value: T) => void;
+	readonly has: (key: string) => boolean;
+	readonly delete: (key: string) => boolean;
+	readonly clear: () => void;
+	readonly getStats: () => CacheStats;
+};
+type CacheOptions = {
+	readonly ttl: number;
+	readonly maxSize: number;
+	readonly onEvict?: (key: string, value: unknown) => void;
+};
+declare const createCache: <T>(options: CacheOptions) => Cache<T>;
+declare const createNoopCache: <T>() => Cache<T>;
+import { GroupEvaluationResult } from "@f-o-t/condition-evaluator";
+type EvaluationContext<TContext = unknown> = {
+	readonly data: TContext;
+	readonly timestamp: Date;
+	readonly correlationId?: string;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type RuleEvaluationResult<
+	_TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly ruleId: string;
+	readonly ruleName: string;
+	readonly matched: boolean;
+	readonly conditionResult: GroupEvaluationResult;
+	readonly consequences: ReadonlyArray<AggregatedConsequence<TConsequences>>;
+	readonly evaluationTimeMs: number;
+	readonly skipped: boolean;
+	readonly skipReason?: string;
+	readonly error?: Error;
+};
+type EngineExecutionResult<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly context: EvaluationContext<TContext>;
+	readonly results: ReadonlyArray<RuleEvaluationResult<TContext, TConsequences>>;
+	readonly matchedRules: ReadonlyArray<Rule<TContext, TConsequences>>;
+	readonly consequences: ReadonlyArray<AggregatedConsequence<TConsequences>>;
+	readonly totalRulesEvaluated: number;
+	readonly totalRulesMatched: number;
+	readonly totalRulesSkipped: number;
+	readonly totalRulesErrored: number;
+	readonly executionTimeMs: number;
+	readonly stoppedEarly: boolean;
+	readonly stoppedByRuleId?: string;
+	readonly cacheHit: boolean;
+};
+type ConflictResolutionStrategy = "priority" | "first-match" | "all" | "most-specific";
+type EvaluateOptions = {
+	readonly conflictResolution?: ConflictResolutionStrategy;
+	readonly maxRules?: number;
+	readonly timeout?: number;
+	readonly skipDisabled?: boolean;
+	readonly tags?: ReadonlyArray<string>;
+	readonly category?: string;
+	readonly ruleSetId?: string;
+	readonly bypassCache?: boolean;
+};
+type EvaluateConfig = {
+	readonly conflictResolution: ConflictResolutionStrategy;
+	readonly continueOnError: boolean;
+	readonly collectAllConsequences: boolean;
+};
+type EvaluateRuleOptions = {
+	readonly skipDisabled?: boolean;
+};
+declare const evaluateRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: Rule<TContext, TConsequences>, context: EvaluationContext<TContext>, options?: EvaluateRuleOptions) => RuleEvaluationResult<TContext, TConsequences>;
+type EvaluateRulesOptions<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly config?: Partial<EvaluateConfig>;
+	readonly onRuleEvaluated?: (result: RuleEvaluationResult<TContext, TConsequences>) => void;
+};
+type EvaluateRulesResult<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly results: ReadonlyArray<RuleEvaluationResult<TContext, TConsequences>>;
+	readonly matchedRules: ReadonlyArray<Rule<TContext, TConsequences>>;
+	readonly consequences: ReadonlyArray<AggregatedConsequence<TConsequences>>;
+	readonly stoppedEarly: boolean;
+	readonly stoppedByRuleId?: string;
+};
+declare const evaluateRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, context: EvaluationContext<TContext>, options?: EvaluateRulesOptions<TContext, TConsequences>) => EvaluateRulesResult<TContext, TConsequences>;
+declare const filterRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(filters: RuleFilters) => (rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const filterByEnabled: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(enabled: boolean) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+declare const filterByTags: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(tags: ReadonlyArray<string>) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+declare const filterByCategory: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(category: string) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+declare const filterByIds: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(ids: ReadonlyArray<string>) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+type GroupByField = "category" | "priority" | "enabled";
+type GroupedRules<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = ReadonlyMap<string | number | boolean, ReadonlyArray<Rule<TContext, TConsequences>>>;
+declare const groupRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(field: GroupByField) => (rules: ReadonlyArray<Rule<TContext, TConsequences>>) => GroupedRules<TContext, TConsequences>;
+declare const groupByCategory: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>() => (rules: readonly Rule<TContext, TConsequences>[]) => GroupedRules<TContext, TConsequences>;
+declare const groupByPriority: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>() => (rules: readonly Rule<TContext, TConsequences>[]) => GroupedRules<TContext, TConsequences>;
+declare const groupByEnabled: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>() => (rules: readonly Rule<TContext, TConsequences>[]) => GroupedRules<TContext, TConsequences>;
+declare const groupByCustom: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences,
+	TKey extends string | number | boolean = string
+>(keyFn: (rule: Rule<TContext, TConsequences>) => TKey) => (rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyMap<TKey, ReadonlyArray<Rule<TContext, TConsequences>>>;
+type SortField = "priority" | "name" | "createdAt" | "updatedAt";
+type SortDirection = "asc" | "desc";
+type SortOptions = {
+	readonly field: SortField;
+	readonly direction?: SortDirection;
+};
+declare const sortRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(options: SortField | SortOptions) => (rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const sortByPriority: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(direction?: SortDirection) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+declare const sortByName: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(direction?: SortDirection) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+declare const sortByCreatedAt: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(direction?: SortDirection) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+declare const sortByUpdatedAt: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(direction?: SortDirection) => (rules: readonly Rule<TContext, TConsequences>[]) => readonly Rule<TContext, TConsequences>[];
+type LogLevel = "none" | "error" | "warn" | "info" | "debug";
+type Logger = {
+	readonly error: (...args: unknown[]) => void;
+	readonly warn: (...args: unknown[]) => void;
+	readonly info: (...args: unknown[]) => void;
+	readonly debug: (...args: unknown[]) => void;
+};
+type CacheConfig = {
+	readonly enabled: boolean;
+	readonly ttl: number;
+	readonly maxSize: number;
+};
+type ValidationConfig = {
+	readonly enabled: boolean;
+	readonly strict: boolean;
+};
+type VersioningConfig = {
+	readonly enabled: boolean;
+	readonly maxVersions: number;
+};
+type EngineHooks<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly beforeEvaluation?: (context: EvaluationContext<TContext>, rules: ReadonlyArray<Rule<TContext, TConsequences>>) => void | Promise<void>;
+	readonly afterEvaluation?: (result: EngineExecutionResult<TContext, TConsequences>) => void | Promise<void>;
+	readonly beforeRuleEvaluation?: (rule: Rule<TContext, TConsequences>, context: EvaluationContext<TContext>) => void | Promise<void>;
+	readonly afterRuleEvaluation?: (rule: Rule<TContext, TConsequences>, result: RuleEvaluationResult<TContext, TConsequences>) => void | Promise<void>;
+	readonly onRuleMatch?: (rule: Rule<TContext, TConsequences>, context: EvaluationContext<TContext>) => void | Promise<void>;
+	readonly onRuleSkip?: (rule: Rule<TContext, TConsequences>, reason: string) => void | Promise<void>;
+	readonly onRuleError?: (rule: Rule<TContext, TConsequences>, error: Error) => void | Promise<void>;
+	readonly onConsequenceCollected?: (rule: Rule<TContext, TConsequences>, consequence: AggregatedConsequence<TConsequences>) => void | Promise<void>;
+	readonly onCacheHit?: (key: string, result: EngineExecutionResult<TContext, TConsequences>) => void | Promise<void>;
+	readonly onCacheMiss?: (key: string) => void | Promise<void>;
+	readonly onSlowRule?: (rule: Rule<TContext, TConsequences>, timeMs: number, threshold: number) => void | Promise<void>;
+};
+type EngineConfig<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly consequences?: TConsequences;
+	readonly conflictResolution?: ConflictResolutionStrategy;
+	readonly cache?: Partial<CacheConfig>;
+	readonly validation?: Partial<ValidationConfig>;
+	readonly versioning?: Partial<VersioningConfig>;
+	readonly hooks?: EngineHooks<TContext, TConsequences>;
+	readonly logLevel?: LogLevel;
+	readonly logger?: Logger;
+	readonly continueOnError?: boolean;
+	readonly slowRuleThresholdMs?: number;
+};
+type ResolvedEngineConfig<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly consequences: TConsequences | undefined;
+	readonly conflictResolution: ConflictResolutionStrategy;
+	readonly cache: CacheConfig;
+	readonly validation: ValidationConfig;
+	readonly versioning: VersioningConfig;
+	readonly hooks: EngineHooks<TContext, TConsequences>;
+	readonly logLevel: LogLevel;
+	readonly logger: Logger;
+	readonly continueOnError: boolean;
+	readonly slowRuleThresholdMs: number;
+};
+declare const DEFAULT_CACHE_CONFIG: CacheConfig;
+declare const DEFAULT_VALIDATION_CONFIG: ValidationConfig;
+declare const DEFAULT_VERSIONING_CONFIG: VersioningConfig;
+declare const DEFAULT_ENGINE_CONFIG: {
+	conflictResolution: ConflictResolutionStrategy;
+	cache: CacheConfig;
+	validation: ValidationConfig;
+	versioning: VersioningConfig;
+	logLevel: LogLevel;
+	continueOnError: boolean;
+	slowRuleThresholdMs: number;
+};
+type Engine<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly addRule: (input: RuleInput<TContext, TConsequences>) => Rule<TContext, TConsequences>;
+	readonly addRules: (inputs: RuleInput<TContext, TConsequences>[]) => Rule<TContext, TConsequences>[];
+	readonly removeRule: (ruleId: string) => boolean;
+	readonly updateRule: (ruleId: string, updates: Partial<RuleInput<TContext, TConsequences>>) => Rule<TContext, TConsequences> | undefined;
+	readonly getRule: (ruleId: string) => Rule<TContext, TConsequences> | undefined;
+	readonly getRules: (filters?: RuleFilters) => ReadonlyArray<Rule<TContext, TConsequences>>;
+	readonly enableRule: (ruleId: string) => boolean;
+	readonly disableRule: (ruleId: string) => boolean;
+	readonly clearRules: () => void;
+	readonly addRuleSet: (input: RuleSetInput) => RuleSet;
+	readonly getRuleSet: (ruleSetId: string) => RuleSet | undefined;
+	readonly getRuleSets: () => ReadonlyArray<RuleSet>;
+	readonly removeRuleSet: (ruleSetId: string) => boolean;
+	readonly evaluate: (context: TContext, options?: EvaluateOptions) => Promise<EngineExecutionResult<TContext, TConsequences>>;
+	readonly clearCache: () => void;
+	readonly getCacheStats: () => CacheStats;
+	readonly getState: () => Readonly<EngineState<TContext, TConsequences>>;
+	readonly getStats: () => EngineStats;
+};
+declare const createEngine: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(config?: EngineConfig<TContext, TConsequences>) => Engine<TContext, TConsequences>;
+declare const addRule2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, input: RuleInput<TContext, TConsequences>) => Rule<TContext, TConsequences>;
+declare const addRules2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, inputs: RuleInput<TContext, TConsequences>[]) => Rule<TContext, TConsequences>[];
+declare const removeRule2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleId: string) => boolean;
+declare const updateRule2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleId: string, updates: Partial<RuleInput<TContext, TConsequences>>) => Rule<TContext, TConsequences> | undefined;
+declare const getRule2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleId: string) => Rule<TContext, TConsequences> | undefined;
+declare const getRules2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, filters?: RuleFilters) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const enableRule2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleId: string) => boolean;
+declare const disableRule2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleId: string) => boolean;
+declare const clearRules2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>) => void;
+declare const addRuleSet2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, input: RuleSetInput) => RuleSet;
+declare const getRuleSet2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleSetId: string) => RuleSet | undefined;
+declare const getRuleSets2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>) => ReadonlyArray<RuleSet>;
+declare const removeRuleSet2: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleSetId: string) => boolean;
+declare const getRulesInSet: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>, ruleSetId: string) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const cloneState: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(state: MutableEngineState<TContext, TConsequences>) => MutableEngineState<TContext, TConsequences>;
+type FieldIndex<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = Map<string, ReadonlyArray<Rule<TContext, TConsequences>>>;
+type TagIndex<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = Map<string, ReadonlyArray<Rule<TContext, TConsequences>>>;
+type CategoryIndex<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = Map<string, ReadonlyArray<Rule<TContext, TConsequences>>>;
+type PriorityIndex<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = Map<number, ReadonlyArray<Rule<TContext, TConsequences>>>;
+type RuleIndex<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly byField: FieldIndex<TContext, TConsequences>;
+	readonly byTag: TagIndex<TContext, TConsequences>;
+	readonly byCategory: CategoryIndex<TContext, TConsequences>;
+	readonly byPriority: PriorityIndex<TContext, TConsequences>;
+	readonly byId: Map<string, Rule<TContext, TConsequences>>;
+	readonly sortedByPriority: ReadonlyArray<Rule<TContext, TConsequences>>;
+};
+type IndexOptions = {
+	readonly indexByField?: boolean;
+	readonly indexByTag?: boolean;
+	readonly indexByCategory?: boolean;
+	readonly indexByPriority?: boolean;
+};
+declare const buildIndex: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, options?: IndexOptions) => RuleIndex<TContext, TConsequences>;
+declare const getRulesByField: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, field: string) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRulesByFields: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, fields: ReadonlyArray<string>, mode?: "any" | "all") => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRulesByTag: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, tag: string) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRulesByTags: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, tags: ReadonlyArray<string>, mode?: "any" | "all") => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRulesByCategory: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, category: string) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRulesByPriority: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, priority: number) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRulesByPriorityRange: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, minPriority: number, maxPriority: number) => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const getRuleById: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, id: string) => Rule<TContext, TConsequences> | undefined;
+declare const filterRulesForContext: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>, contextFields: ReadonlyArray<string>) => ReadonlyArray<Rule<TContext, TConsequences>>;
+type OptimizationSuggestion = {
+	readonly type: "INDEX" | "CACHE" | "MERGE" | "SIMPLIFY" | "REORDER";
+	readonly severity: "high" | "medium" | "low";
+	readonly message: string;
+	readonly ruleIds?: ReadonlyArray<string>;
+	readonly details?: Readonly<Record<string, unknown>>;
+};
+declare const analyzeOptimizations: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<OptimizationSuggestion>;
+declare const getIndexStats: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(index: RuleIndex<TContext, TConsequences>) => {
+	totalRules: number;
+	uniqueFields: number;
+	uniqueTags: number;
+	uniqueCategories: number;
+	uniquePriorities: number;
+	averageRulesPerField: number;
+	averageRulesPerTag: number;
+};
+import { ConditionGroup as ConditionGroup4 } from "@f-o-t/condition-evaluator";
+type SerializedRule = {
+	readonly id: string;
+	readonly name: string;
+	readonly description?: string;
+	readonly conditions: ConditionGroup4;
+	readonly consequences: ReadonlyArray<{
+		type: string;
+		payload: unknown;
+	}>;
+	readonly priority: number;
+	readonly enabled: boolean;
+	readonly stopOnMatch: boolean;
+	readonly tags: ReadonlyArray<string>;
+	readonly category?: string;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+	readonly createdAt: string;
+	readonly updatedAt: string;
+};
+type SerializedRuleSet = {
+	readonly id: string;
+	readonly name: string;
+	readonly description?: string;
+	readonly ruleIds: ReadonlyArray<string>;
+	readonly enabled: boolean;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type ExportFormat = {
+	readonly version: string;
+	readonly exportedAt: string;
+	readonly rules: ReadonlyArray<SerializedRule>;
+	readonly ruleSets?: ReadonlyArray<SerializedRuleSet>;
+	readonly metadata?: Readonly<Record<string, unknown>>;
+};
+type ImportOptions = {
+	readonly generateNewIds?: boolean;
+	readonly idPrefix?: string;
+	readonly preserveDates?: boolean;
+	readonly validateSchema?: boolean;
+};
+type ImportResult<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly success: boolean;
+	readonly rules: ReadonlyArray<Rule<TContext, TConsequences>>;
+	readonly ruleSets: ReadonlyArray<RuleSet>;
+	readonly errors: ReadonlyArray<{
+		index: number;
+		type: "rule" | "ruleSet";
+		message: string;
+	}>;
+	readonly idMapping: ReadonlyMap<string, string>;
+};
+declare const serializeRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: Rule<TContext, TConsequences>) => SerializedRule;
+declare const deserializeRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(serialized: SerializedRule, options?: ImportOptions) => Rule<TContext, TConsequences>;
+declare const serializeRuleSet: (ruleSet: RuleSet) => SerializedRuleSet;
+declare const deserializeRuleSet: (serialized: SerializedRuleSet, idMapping: Map<string, string>, options?: ImportOptions) => RuleSet;
+declare const exportRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, ruleSets?: ReadonlyArray<RuleSet>, metadata?: Record<string, unknown>) => ExportFormat;
+declare const exportToJson: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, ruleSets?: ReadonlyArray<RuleSet>, metadata?: Record<string, unknown>) => string;
+declare const importRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(data: ExportFormat, options?: ImportOptions) => ImportResult<TContext, TConsequences>;
+declare const importFromJson: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(json: string, options?: ImportOptions) => ImportResult<TContext, TConsequences>;
+declare const cloneRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: Rule<TContext, TConsequences>, newId?: string, newName?: string) => Rule<TContext, TConsequences>;
+declare const mergeRuleSets: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(baseRules: ReadonlyArray<Rule<TContext, TConsequences>>, incomingRules: ReadonlyArray<Rule<TContext, TConsequences>>, strategy?: "replace" | "skip" | "merge") => ReadonlyArray<Rule<TContext, TConsequences>>;
+declare const diffRuleSets: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(oldRules: ReadonlyArray<Rule<TContext, TConsequences>>, newRules: ReadonlyArray<Rule<TContext, TConsequences>>) => {
+	added: ReadonlyArray<Rule<TContext, TConsequences>>;
+	removed: ReadonlyArray<Rule<TContext, TConsequences>>;
+	modified: ReadonlyArray<{
+		old: Rule<TContext, TConsequences>;
+		new: Rule<TContext, TConsequences>;
+	}>;
+	unchanged: ReadonlyArray<Rule<TContext, TConsequences>>;
+};
+type SimulationContext<TContext = unknown> = {
+	readonly data: TContext;
+	readonly metadata?: Record<string, unknown>;
+};
+type SimulationResult<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly context: SimulationContext<TContext>;
+	readonly matchedRules: ReadonlyArray<RuleEvaluationResult<TContext, TConsequences>>;
+	readonly unmatchedRules: ReadonlyArray<{
+		ruleId: string;
+		ruleName: string;
+		reason: string;
+	}>;
+	readonly consequences: ReadonlyArray<{
+		type: keyof TConsequences;
+		payload: unknown;
+		ruleId: string;
+		ruleName: string;
+	}>;
+	readonly executionTimeMs: number;
+};
+type WhatIfResult<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly original: SimulationResult<TContext, TConsequences>;
+	readonly modified: SimulationResult<TContext, TConsequences>;
+	readonly differences: {
+		readonly newMatches: ReadonlyArray<string>;
+		readonly lostMatches: ReadonlyArray<string>;
+		readonly consequenceChanges: ReadonlyArray<{
+			type: "added" | "removed" | "modified";
+			consequenceType: string;
+			ruleId: string;
+		}>;
+	};
+};
+type BatchSimulationResult<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly results: ReadonlyArray<SimulationResult<TContext, TConsequences>>;
+	readonly summary: {
+		readonly totalContexts: number;
+		readonly averageMatchedRules: number;
+		readonly ruleMatchFrequency: ReadonlyMap<string, number>;
+		readonly consequenceFrequency: ReadonlyMap<string, number>;
+		readonly averageExecutionTimeMs: number;
+	};
+};
+declare const simulate: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, context: SimulationContext<TContext>) => SimulationResult<TContext, TConsequences>;
+declare const simulateSingleRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: Rule<TContext, TConsequences>, context: SimulationContext<TContext>) => {
+	matched: boolean;
+	conditionResult: unknown;
+	consequences: ReadonlyArray<{
+		type: keyof TConsequences;
+		payload: unknown;
+	}>;
+};
+declare const whatIf: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(originalRules: ReadonlyArray<Rule<TContext, TConsequences>>, modifiedRules: ReadonlyArray<Rule<TContext, TConsequences>>, context: SimulationContext<TContext>) => WhatIfResult<TContext, TConsequences>;
+declare const batchSimulate: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, contexts: ReadonlyArray<SimulationContext<TContext>>) => BatchSimulationResult<TContext, TConsequences>;
+declare const findRulesAffectedByContextChange: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, originalContext: SimulationContext<TContext>, modifiedContext: SimulationContext<TContext>) => {
+	becameTrue: ReadonlyArray<Rule<TContext, TConsequences>>;
+	becameFalse: ReadonlyArray<Rule<TContext, TConsequences>>;
+	unchanged: ReadonlyArray<Rule<TContext, TConsequences>>;
+};
+declare const formatSimulationResult: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(result: SimulationResult<TContext, TConsequences>) => string;
+declare const hashContext: (context: unknown) => string;
+declare const hashRules: (ruleIds: ReadonlyArray<string>) => string;
+declare const generateId: () => string;
+type UnaryFn<
+	A,
+	B
+> = (a: A) => B;
+declare function pipe<
+	A,
+	B
+>(fn1: UnaryFn<A, B>): UnaryFn<A, B>;
+declare function pipe<
+	A,
+	B,
+	C
+>(fn1: UnaryFn<A, B>, fn2: UnaryFn<B, C>): UnaryFn<A, C>;
+declare function pipe<
+	A,
+	B,
+	C,
+	D
+>(fn1: UnaryFn<A, B>, fn2: UnaryFn<B, C>, fn3: UnaryFn<C, D>): UnaryFn<A, D>;
+declare function pipe<
+	A,
+	B,
+	C,
+	D,
+	E
+>(fn1: UnaryFn<A, B>, fn2: UnaryFn<B, C>, fn3: UnaryFn<C, D>, fn4: UnaryFn<D, E>): UnaryFn<A, E>;
+declare function pipe<
+	A,
+	B,
+	C,
+	D,
+	E,
+	F
+>(fn1: UnaryFn<A, B>, fn2: UnaryFn<B, C>, fn3: UnaryFn<C, D>, fn4: UnaryFn<D, E>, fn5: UnaryFn<E, F>): UnaryFn<A, F>;
+declare function pipe<
+	A,
+	B,
+	C,
+	D,
+	E,
+	F,
+	G
+>(fn1: UnaryFn<A, B>, fn2: UnaryFn<B, C>, fn3: UnaryFn<C, D>, fn4: UnaryFn<D, E>, fn5: UnaryFn<E, F>, fn6: UnaryFn<F, G>): UnaryFn<A, G>;
+declare function compose<
+	A,
+	B
+>(fn1: UnaryFn<A, B>): UnaryFn<A, B>;
+declare function compose<
+	A,
+	B,
+	C
+>(fn1: UnaryFn<B, C>, fn2: UnaryFn<A, B>): UnaryFn<A, C>;
+declare function compose<
+	A,
+	B,
+	C,
+	D
+>(fn1: UnaryFn<C, D>, fn2: UnaryFn<B, C>, fn3: UnaryFn<A, B>): UnaryFn<A, D>;
+declare function compose<
+	A,
+	B,
+	C,
+	D,
+	E
+>(fn1: UnaryFn<D, E>, fn2: UnaryFn<C, D>, fn3: UnaryFn<B, C>, fn4: UnaryFn<A, B>): UnaryFn<A, E>;
+declare function compose<
+	A,
+	B,
+	C,
+	D,
+	E,
+	F
+>(fn1: UnaryFn<E, F>, fn2: UnaryFn<D, E>, fn3: UnaryFn<C, D>, fn4: UnaryFn<B, C>, fn5: UnaryFn<A, B>): UnaryFn<A, F>;
+declare const identity: <T>(value: T) => T;
+declare const always: <T>(value: T) => () => T;
+declare const tap: <T>(fn: (value: T) => void) => (value: T) => T;
+type TimingResult<T> = {
+	readonly result: T;
+	readonly durationMs: number;
+};
+declare const measureTime: <T>(fn: () => T) => TimingResult<T>;
+declare const measureTimeAsync: <T>(fn: () => Promise<T>) => Promise<TimingResult<T>>;
+declare const withTimeout: <T>(promise: Promise<T>, timeoutMs: number, errorMessage?: string) => Promise<T>;
+declare const delay: (ms: number) => Promise<void>;
+type ConflictType = "DUPLICATE_ID" | "DUPLICATE_CONDITIONS" | "OVERLAPPING_CONDITIONS" | "CONTRADICTORY_CONSEQUENCES" | "PRIORITY_COLLISION" | "UNREACHABLE_RULE";
+type Conflict<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly type: ConflictType;
+	readonly severity: "error" | "warning" | "info";
+	readonly message: string;
+	readonly ruleIds: ReadonlyArray<string>;
+	readonly rules: ReadonlyArray<Rule<TContext, TConsequences>>;
+	readonly details?: Readonly<Record<string, unknown>>;
+};
+type ConflictDetectionOptions = {
+	readonly checkDuplicateIds?: boolean;
+	readonly checkDuplicateConditions?: boolean;
+	readonly checkOverlappingConditions?: boolean;
+	readonly checkPriorityCollisions?: boolean;
+	readonly checkUnreachableRules?: boolean;
+};
+declare const detectConflicts: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, options?: ConflictDetectionOptions) => ReadonlyArray<Conflict<TContext, TConsequences>>;
+declare const hasConflicts: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, options?: ConflictDetectionOptions) => boolean;
+declare const hasErrors: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, options?: ConflictDetectionOptions) => boolean;
+declare const getConflictsByType: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(conflicts: ReadonlyArray<Conflict<TContext, TConsequences>>, type: ConflictType) => ReadonlyArray<Conflict<TContext, TConsequences>>;
+declare const getConflictsBySeverity: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(conflicts: ReadonlyArray<Conflict<TContext, TConsequences>>, severity: "error" | "warning" | "info") => ReadonlyArray<Conflict<TContext, TConsequences>>;
+declare const formatConflicts: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(conflicts: ReadonlyArray<Conflict<TContext, TConsequences>>) => string;
+type IntegrityIssue = {
+	readonly code: string;
+	readonly message: string;
+	readonly severity: "error" | "warning" | "info";
+	readonly path?: string;
+	readonly ruleId?: string;
+	readonly details?: Readonly<Record<string, unknown>>;
+};
+type IntegrityCheckResult = {
+	readonly valid: boolean;
+	readonly issues: ReadonlyArray<IntegrityIssue>;
+};
+type IntegrityCheckOptions = {
+	readonly checkCircularReferences?: boolean;
+	readonly checkOrphanedRuleSets?: boolean;
+	readonly checkMissingReferences?: boolean;
+	readonly checkFieldConsistency?: boolean;
+	readonly requiredFields?: ReadonlyArray<string>;
+	readonly allowedCategories?: ReadonlyArray<string>;
+	readonly allowedTags?: ReadonlyArray<string>;
+};
+declare const checkIntegrity: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, ruleSets?: ReadonlyArray<RuleSet>, options?: IntegrityCheckOptions) => IntegrityCheckResult;
+declare const checkRuleFieldCoverage: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>, expectedFields: ReadonlyArray<string>) => {
+	coveredFields: ReadonlyArray<string>;
+	uncoveredFields: ReadonlyArray<string>;
+	extraFields: ReadonlyArray<string>;
+	coveragePercentage: number;
+};
+declare const getUsedFields: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<string>;
+declare const getUsedOperators: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => ReadonlyArray<{
+	field: string;
+	operator: string;
+	type: string;
+}>;
+declare const formatIntegrityResult: (result: IntegrityCheckResult) => string;
+import { ConditionGroup as ConditionGroup5 } from "@f-o-t/condition-evaluator";
+type ValidationError = {
+	readonly path: string;
+	readonly message: string;
+	readonly code: string;
+};
+type ValidationResult = {
+	readonly valid: boolean;
+	readonly errors: ReadonlyArray<ValidationError>;
+};
+type ValidationOptions = {
+	readonly validateConditions?: boolean;
+	readonly validateConsequences?: boolean;
+	readonly strictMode?: boolean;
+};
+declare const validateRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: unknown, options?: ValidationOptions & {
+	consequenceSchemas?: TConsequences;
+}) => ValidationResult;
+declare const validateRules: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rules: ReadonlyArray<unknown>, options?: ValidationOptions & {
+	consequenceSchemas?: TConsequences;
+}) => ValidationResult;
+declare const validateRuleSet: (ruleSet: unknown) => ValidationResult;
+declare const validateConditions: (conditions: ConditionGroup5) => ValidationResult;
+declare const parseRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: unknown, options?: ValidationOptions & {
+	consequenceSchemas?: TConsequences;
+}) => Rule<TContext, TConsequences>;
+declare const safeParseRule: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(rule: unknown, options?: ValidationOptions & {
+	consequenceSchemas?: TConsequences;
+}) => {
+	success: true;
+	data: Rule<TContext, TConsequences>;
+} | {
+	success: false;
+	errors: ReadonlyArray<ValidationError>;
+};
+declare const createRuleValidator: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(consequenceSchemas: TConsequences, defaultOptions?: ValidationOptions) => {
+	validate: (rule: unknown, options?: ValidationOptions) => ValidationResult;
+	parse: (rule: unknown, options?: ValidationOptions) => Rule<TContext, TConsequences>;
+	safeParse: (rule: unknown, options?: ValidationOptions) => {
+		success: false;
+		errors: ReadonlyArray<ValidationError>;
+	} | {
+		success: true;
+		data: Rule<TContext, TConsequences>;
+	};
+};
+type RuleVersion<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly versionId: string;
+	readonly ruleId: string;
+	readonly version: number;
+	readonly rule: Rule<TContext, TConsequences>;
+	readonly createdAt: Date;
+	readonly createdBy?: string;
+	readonly comment?: string;
+	readonly changeType: "create" | "update" | "delete" | "enable" | "disable";
+};
+type VersionHistory<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly ruleId: string;
+	readonly currentVersion: number;
+	readonly versions: ReadonlyArray<RuleVersion<TContext, TConsequences>>;
+};
+type VersionStore<
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+> = {
+	readonly histories: ReadonlyMap<string, VersionHistory<TContext, TConsequences>>;
+};
+declare const createVersionStore: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>() => VersionStore<TContext, TConsequences>;
+declare const addVersion: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, rule: Rule<TContext, TConsequences>, changeType: RuleVersion<TContext, TConsequences>["changeType"], options?: {
+	createdBy?: string;
+	comment?: string;
+}) => VersionStore<TContext, TConsequences>;
+declare const getHistory: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, ruleId: string) => VersionHistory<TContext, TConsequences> | undefined;
+declare const getVersion: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, ruleId: string, version: number) => RuleVersion<TContext, TConsequences> | undefined;
+declare const getLatestVersion: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, ruleId: string) => RuleVersion<TContext, TConsequences> | undefined;
+declare const getAllVersions: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, ruleId: string) => ReadonlyArray<RuleVersion<TContext, TConsequences>>;
+declare const rollbackToVersion: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, ruleId: string, targetVersion: number, options?: {
+	createdBy?: string;
+	comment?: string;
+}) => {
+	store: VersionStore<TContext, TConsequences>;
+	rule: Rule<TContext, TConsequences> | undefined;
+};
+declare const compareVersions: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, ruleId: string, version1: number, version2: number) => {
+	version1: RuleVersion<TContext, TConsequences> | undefined;
+	version2: RuleVersion<TContext, TConsequences> | undefined;
+	differences: ReadonlyArray<{
+		field: string;
+		oldValue: unknown;
+		newValue: unknown;
+	}>;
+} | null;
+declare const getVersionsByDateRange: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, startDate: Date, endDate: Date) => ReadonlyArray<RuleVersion<TContext, TConsequences>>;
+declare const getVersionsByChangeType: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, changeType: RuleVersion<TContext, TConsequences>["changeType"]) => ReadonlyArray<RuleVersion<TContext, TConsequences>>;
+declare const pruneOldVersions: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(store: VersionStore<TContext, TConsequences>, keepCount: number) => VersionStore<TContext, TConsequences>;
+declare const formatVersionHistory: <
+	TContext = unknown,
+	TConsequences extends ConsequenceDefinitions = DefaultConsequences
+>(history: VersionHistory<TContext, TConsequences>) => string;
+export { withTimeout, whatIf, validateRules, validateRuleSet, validateRule, validateConditions, updateRule2 as updateRule, tap, str, sortRules, sortByUpdatedAt, sortByPriority, sortByName, sortByCreatedAt, simulateSingleRule, simulate, serializeRuleSet, serializeRule, safeParseRule, rule, rollbackToVersion, resetBuilderIds, removeRuleSet2 as removeRuleSet, removeRule2 as removeRule, pruneOldVersions, pipe, parseRule, or, num, mergeRuleSets, measureTimeAsync, measureTime, importRules, importFromJson, identity, hashRules, hashContext, hasErrors, hasConflicts, groupRules, groupByPriority, groupByEnabled, groupByCustom, groupByCategory, getVersionsByDateRange, getVersionsByChangeType, getVersion, getUsedOperators, getUsedFields, getRulesInSet, getRulesByTags, getRulesByTag, getRulesByPriorityRange, getRulesByPriority, getRulesByFields, getRulesByField, getRulesByCategory, getRules2 as getRules, getRuleSets2 as getRuleSets, getRuleSet2 as getRuleSet, getRuleById, getRule2 as getRule, getLatestVersion, getIndexStats, getHistory, getConflictsByType, getConflictsBySeverity, getAllVersions, generateId, formatVersionHistory, formatSimulationResult, formatRuleSetAnalysis, formatIntegrityResult, formatConflicts, findRulesAffectedByContextChange, findMostComplexRules, findLeastUsedFields, filterRulesForContext, filterRules, filterByTags, filterByIds, filterByEnabled, filterByCategory, exportToJson, exportRules, evaluateRules, evaluateRule, enableRule2 as enableRule, disableRule2 as disableRule, diffRuleSets, detectConflicts, deserializeRuleSet, deserializeRule, delay, date, createVersionStore, createRuleValidator, createRule, createNoopCache, createInitialState, createInitialRuleStats, createInitialOptimizerState, createEngine, createCache, conditions, compose, compareVersions, cloneState, cloneRule, clearRules2 as clearRules, checkRuleFieldCoverage, checkIntegrity, buildIndex, bool, batchSimulate, arr, any, and, analyzeRuleSet, analyzeRuleComplexity, analyzeOptimizations, analyzeOperatorUsage, analyzeFieldUsage, analyzeConsequenceUsage, always, all, addVersion, addRules2 as addRules, addRuleSet2 as addRuleSet, addRule2 as addRule, WhatIfResult, VersioningConfig, VersionStore, VersionHistory, ValidationResult, ValidationOptions, ValidationError, ValidationConfig, TimingResult, TagIndex, StringCondition, SortOptions, SortField, SortDirection, SimulationResult, SimulationContext, SerializedRuleSet, SerializedRule, RuleVersion, RuleStats, RuleSetSchemaType, RuleSetSchema, RuleSetInput, RuleSetAnalysis, RuleSet, RuleSchemaType, RuleSchema, RuleInput, RuleIndex, RuleFilters, RuleEvaluationResult, RuleComplexity, RuleBuilderState, RuleBuilder, Rule, ResolvedEngineConfig, PriorityIndex, OptimizerState, OptimizationSuggestion, OperatorUsage, NumberCondition, MutableRuleStats, MutableOptimizerState, MutableEngineState, LogicalOperator, Logger, LogLevel, IntegrityIssue, IntegrityCheckResult, IntegrityCheckOptions, InferConsequenceType, InferConsequencePayload, IndexOptions, ImportResult, ImportOptions, GroupedRules, GroupEvaluationResult2 as GroupEvaluationResult, GroupByField, FieldUsage, FieldIndex, ExportFormat, EvaluationResult, EvaluationContext, EvaluateRulesResult, EvaluateRulesOptions, EvaluateRuleOptions, EvaluateOptions, EvaluateConfig, EngineStats, EngineState, EngineHooks, EngineExecutionResult, EngineConfig, Engine, DefaultConsequences, DateCondition, DEFAULT_VERSIONING_CONFIG, DEFAULT_VALIDATION_CONFIG, DEFAULT_ENGINE_CONFIG, DEFAULT_CACHE_CONFIG, CustomCondition, ConsequenceUsage, ConsequenceInput, ConsequenceDefinitions, Consequence, ConflictType, ConflictResolutionStrategy, ConflictDetectionOptions, Conflict, ConditionGroup6 as ConditionGroup, ConditionBuilderState, ConditionBuilder, Condition2 as Condition, CategoryIndex, CacheStats, CacheOptions, CacheEntry, CacheConfig, Cache, BooleanCondition, BatchSimulationResult, ArrayCondition, AggregatedConsequence };