@f-o-t/rules-engine 1.0.0 → 2.0.1

package/dist/index.d.cts

@@ -1,4 +1,5 @@
-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 { ArrayCondition, ArrayOperator, BooleanCondition, BooleanOperator, Condition as Condition3, ConditionGroup as ConditionGroup6, CustomCondition, DateCondition, DateOperator, EvaluationResult, GroupEvaluationResult as GroupEvaluationResult2, LogicalOperator, NumberCondition, NumberOperator, StringCondition, StringOperator } from "@f-o-t/condition-evaluator";
+import { ConditionGroup as ConditionGroup7, isConditionGroup } from "@f-o-t/condition-evaluator";
 import { z } from "zod";
 type ConsequenceDefinitions = Record<string, z.ZodType>;
 type DefaultConsequences = Record<string, z.ZodType>;
@@ -94,7 +95,35 @@ 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>;
+	conditions: z2.ZodCustom<{
+		id: string;
+		operator: "AND" | "OR";
+		scoringMode?: "binary" | "weighted" | undefined;
+		threshold?: number | undefined;
+		weight?: number | undefined;
+	} & {
+		conditions: (import("@f-o-t/condition-evaluator").Condition | ({
+			id: string;
+			operator: "AND" | "OR";
+			scoringMode?: "binary" | "weighted" | undefined;
+			threshold?: number | undefined;
+			weight?: number | undefined;
+		} & any))[];
+	}, {
+		id: string;
+		operator: "AND" | "OR";
+		scoringMode?: "binary" | "weighted" | undefined;
+		threshold?: number | undefined;
+		weight?: number | undefined;
+	} & {
+		conditions: (import("@f-o-t/condition-evaluator").Condition | ({
+			id: string;
+			operator: "AND" | "OR";
+			scoringMode?: "binary" | "weighted" | undefined;
+			threshold?: number | undefined;
+			weight?: number | undefined;
+		} & any))[];
+	}>;
 	consequences: z2.ZodArray<z2.ZodObject<{
 		type: z2.ZodString;
 		payload: z2.ZodUnknown;
@@ -129,10 +158,7 @@ type RuleComplexity = {
 	readonly consequenceCount: number;
 	readonly complexityScore: number;
 };
-type RuleSetAnalysis<
-	TContext = unknown,
-	TConsequences extends ConsequenceDefinitions = DefaultConsequences
-> = {
+type RuleSetAnalysis = {
 	readonly ruleCount: number;
 	readonly enabledCount: number;
 	readonly disabledCount: number;
@@ -189,7 +215,7 @@ declare const analyzeRuleComplexity: <
 declare const analyzeRuleSet: <
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
->(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => RuleSetAnalysis<TContext, TConsequences>;
+>(rules: ReadonlyArray<Rule<TContext, TConsequences>>) => RuleSetAnalysis;
 declare const analyzeFieldUsage: <
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
@@ -210,13 +236,10 @@ 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";
+declare const formatRuleSetAnalysis: (analysis: RuleSetAnalysis) => string;
+import { Condition as Condition2, ConditionGroup as ConditionGroup2 } from "@f-o-t/condition-evaluator";
 type ConditionBuilderState = {
-	readonly conditions: (Condition | ConditionGroup2)[];
+	readonly conditions: (Condition2 | ConditionGroup2)[];
 };
 type ConditionBuilder = {
 	readonly number: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq", value: number) => ConditionBuilder;
@@ -227,21 +250,21 @@ type 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 raw: (condition: Condition2 | ConditionGroup2) => ConditionBuilder;
 	readonly build: () => ConditionGroup2;
-	readonly getConditions: () => ReadonlyArray<Condition | ConditionGroup2>;
+	readonly getConditions: () => ReadonlyArray<Condition2 | 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;
+declare const all: (...items: (Condition2 | ConditionGroup2)[]) => ConditionGroup2;
+declare const any: (...items: (Condition2 | ConditionGroup2)[]) => ConditionGroup2;
+declare const num: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq", value: number) => Condition2;
+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[]) => Condition2;
+declare const bool: (field: string, operator: "eq" | "neq", value: boolean) => Condition2;
+declare const date: (field: string, operator: "gt" | "gte" | "lt" | "lte" | "eq" | "neq" | "between", value: string | Date | [string | Date, string | Date]) => Condition2;
+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) => Condition2;
 import { ConditionGroup as ConditionGroup3 } from "@f-o-t/condition-evaluator";
 import { z as z3 } from "zod";
 type RuleBuilderState<
@@ -290,6 +313,39 @@ declare const createRule: <
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
 >(builderFn: (rb: RuleBuilder<TContext, TConsequences>) => RuleBuilder<TContext, TConsequences>) => RuleInput<TContext, TConsequences>;
+import { z as z4 } from "zod";
+declare const RuleStatsSchema: z4.ZodObject<{
+	evaluations: z4.ZodNumber;
+	matches: z4.ZodNumber;
+	errors: z4.ZodNumber;
+	totalTimeMs: z4.ZodNumber;
+	avgTimeMs: z4.ZodNumber;
+	lastEvaluated: z4.ZodOptional<z4.ZodDate>;
+}, z4.core.$strip>;
+type RuleStats = z4.infer<typeof RuleStatsSchema>;
+declare const CacheStatsSchema: z4.ZodObject<{
+	size: z4.ZodNumber;
+	maxSize: z4.ZodNumber;
+	hits: z4.ZodNumber;
+	misses: z4.ZodNumber;
+	hitRate: z4.ZodNumber;
+	evictions: z4.ZodNumber;
+}, z4.core.$strip>;
+type CacheStats = z4.infer<typeof CacheStatsSchema>;
+declare const EngineStatsSchema: z4.ZodObject<{
+	totalRules: z4.ZodNumber;
+	enabledRules: z4.ZodNumber;
+	disabledRules: z4.ZodNumber;
+	totalRuleSets: z4.ZodNumber;
+	totalEvaluations: z4.ZodNumber;
+	totalMatches: z4.ZodNumber;
+	totalErrors: z4.ZodNumber;
+	avgEvaluationTimeMs: z4.ZodNumber;
+	cacheHits: z4.ZodNumber;
+	cacheMisses: z4.ZodNumber;
+	cacheHitRate: z4.ZodNumber;
+}, z4.core.$strip>;
+type EngineStats = z4.infer<typeof EngineStatsSchema>;
 type EngineState<
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
@@ -306,14 +362,6 @@ type MutableEngineState<
 	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;
@@ -330,27 +378,6 @@ 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
@@ -378,6 +405,41 @@ type CacheOptions = {
 declare const createCache: <T>(options: CacheOptions) => Cache<T>;
 declare const createNoopCache: <T>() => Cache<T>;
 import { GroupEvaluationResult } from "@f-o-t/condition-evaluator";
+import { z as z5 } from "zod";
+declare const ConflictResolutionStrategySchema: z5.ZodEnum<{
+	priority: "priority";
+	"first-match": "first-match";
+	all: "all";
+	"most-specific": "most-specific";
+}>;
+type ConflictResolutionStrategy = z5.infer<typeof ConflictResolutionStrategySchema>;
+declare const EvaluateOptionsSchema: z5.ZodObject<{
+	conflictResolution: z5.ZodOptional<z5.ZodEnum<{
+		priority: "priority";
+		"first-match": "first-match";
+		all: "all";
+		"most-specific": "most-specific";
+	}>>;
+	maxRules: z5.ZodOptional<z5.ZodNumber>;
+	timeout: z5.ZodOptional<z5.ZodNumber>;
+	skipDisabled: z5.ZodOptional<z5.ZodBoolean>;
+	tags: z5.ZodOptional<z5.ZodArray<z5.ZodString>>;
+	category: z5.ZodOptional<z5.ZodString>;
+	ruleSetId: z5.ZodOptional<z5.ZodString>;
+	bypassCache: z5.ZodOptional<z5.ZodBoolean>;
+}, z5.core.$strip>;
+type EvaluateOptions = z5.infer<typeof EvaluateOptionsSchema>;
+declare const EvaluateConfigSchema: z5.ZodObject<{
+	conflictResolution: z5.ZodEnum<{
+		priority: "priority";
+		"first-match": "first-match";
+		all: "all";
+		"most-specific": "most-specific";
+	}>;
+	continueOnError: z5.ZodBoolean;
+	collectAllConsequences: z5.ZodBoolean;
+}, z5.core.$strip>;
+type EvaluateConfig = z5.infer<typeof EvaluateConfigSchema>;
 type EvaluationContext<TContext = unknown> = {
 	readonly data: TContext;
 	readonly timestamp: Date;
@@ -415,22 +477,6 @@ type EngineExecutionResult<
 	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;
 };
@@ -531,26 +577,37 @@ 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";
+import { z as z6 } from "zod";
+declare const LogLevelSchema: z6.ZodEnum<{
+	error: "error";
+	none: "none";
+	warn: "warn";
+	info: "info";
+	debug: "debug";
+}>;
+type LogLevel = z6.infer<typeof LogLevelSchema>;
+declare const CacheConfigSchema: z6.ZodObject<{
+	enabled: z6.ZodDefault<z6.ZodBoolean>;
+	ttl: z6.ZodDefault<z6.ZodNumber>;
+	maxSize: z6.ZodDefault<z6.ZodNumber>;
+}, z6.core.$strip>;
+type CacheConfig = z6.infer<typeof CacheConfigSchema>;
+declare const ValidationConfigSchema: z6.ZodObject<{
+	enabled: z6.ZodDefault<z6.ZodBoolean>;
+	strict: z6.ZodDefault<z6.ZodBoolean>;
+}, z6.core.$strip>;
+type ValidationConfig = z6.infer<typeof ValidationConfigSchema>;
+declare const VersioningConfigSchema: z6.ZodObject<{
+	enabled: z6.ZodDefault<z6.ZodBoolean>;
+	maxVersions: z6.ZodDefault<z6.ZodNumber>;
+}, z6.core.$strip>;
+type VersioningConfig = z6.infer<typeof VersioningConfigSchema>;
 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
@@ -566,6 +623,7 @@ type EngineHooks<
 	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>;
+	readonly onHookError?: (hookName: string, error: Error) => void;
 };
 type EngineConfig<
 	TContext = unknown,
@@ -581,6 +639,7 @@ type EngineConfig<
 	readonly logger?: Logger;
 	readonly continueOnError?: boolean;
 	readonly slowRuleThresholdMs?: number;
+	readonly hookTimeoutMs?: number;
 };
 type ResolvedEngineConfig<
 	TContext = unknown,
@@ -596,19 +655,16 @@ type ResolvedEngineConfig<
 	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;
-};
+	readonly hookTimeoutMs: number | undefined;
+};
+declare const parseCacheConfig: (input?: Partial<CacheConfig>) => CacheConfig;
+declare const parseValidationConfig: (input?: Partial<ValidationConfig>) => ValidationConfig;
+declare const parseVersioningConfig: (input?: Partial<VersioningConfig>) => VersioningConfig;
+declare const getDefaultCacheConfig: () => CacheConfig;
+declare const getDefaultValidationConfig: () => ValidationConfig;
+declare const getDefaultVersioningConfig: () => VersioningConfig;
+declare const getDefaultLogLevel: () => LogLevel;
+declare const getDefaultConflictResolution: () => ConflictResolutionStrategy;
 type Engine<
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
@@ -832,6 +888,11 @@ type ImportOptions = {
 	readonly preserveDates?: boolean;
 	readonly validateSchema?: boolean;
 };
+type OrphanedReference = {
+	readonly ruleSetId: string;
+	readonly ruleSetName: string;
+	readonly missingRuleIds: ReadonlyArray<string>;
+};
 type ImportResult<
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
@@ -845,6 +906,7 @@ type ImportResult<
 		message: string;
 	}>;
 	readonly idMapping: ReadonlyMap<string, string>;
+	readonly orphanedReferences: ReadonlyArray<OrphanedReference>;
 };
 declare const serializeRule: <
 	TContext = unknown,
@@ -982,82 +1044,6 @@ declare const formatSimulationResult: <
 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;
@@ -1065,7 +1051,6 @@ type TimingResult<T> = {
 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,
@@ -1157,19 +1142,32 @@ declare const getUsedOperators: <
 }>;
 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;
+import { z as z7 } from "zod";
+declare const ValidationErrorSchema: z7.ZodObject<{
+	path: z7.ZodString;
+	message: z7.ZodString;
+	code: z7.ZodString;
+}, z7.core.$strip>;
+type ValidationError = z7.infer<typeof ValidationErrorSchema>;
+declare const ValidationResultSchema: z7.ZodObject<{
+	valid: z7.ZodBoolean;
+	errors: z7.ZodArray<z7.ZodObject<{
+		path: z7.ZodString;
+		message: z7.ZodString;
+		code: z7.ZodString;
+	}, z7.core.$strip>>;
+}, z7.core.$strip>;
+type ValidationResult = z7.infer<typeof ValidationResultSchema>;
+declare const ValidationOptionsSchema: z7.ZodObject<{
+	validateConditions: z7.ZodOptional<z7.ZodBoolean>;
+	validateConsequences: z7.ZodOptional<z7.ZodBoolean>;
+	strictMode: z7.ZodOptional<z7.ZodBoolean>;
+}, z7.core.$strip>;
+type ValidationOptions = z7.infer<typeof ValidationOptionsSchema>;
+type ResolvedValidationOptions = {
+	validateConditions: boolean;
+	validateConsequences: boolean;
+	strictMode: boolean;
 };
 declare const validateRule: <
 	TContext = unknown,
@@ -1207,7 +1205,14 @@ declare const createRuleValidator: <
 	TContext = unknown,
 	TConsequences extends ConsequenceDefinitions = DefaultConsequences
 >(consequenceSchemas: TConsequences, defaultOptions?: ValidationOptions) => {
-	validate: (rule: unknown, options?: ValidationOptions) => ValidationResult;
+	validate: (rule: unknown, options?: ValidationOptions) => {
+		valid: boolean;
+		errors: {
+			path: string;
+			message: string;
+			code: string;
+		}[];
+	};
 	parse: (rule: unknown, options?: ValidationOptions) => Rule<TContext, TConsequences>;
 	safeParse: (rule: unknown, options?: ValidationOptions) => {
 		success: false;
@@ -1309,4 +1314,4 @@ 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 };
+export { withTimeout, whatIf, validateRules, validateRuleSet, validateRule, validateConditions, updateRule2 as updateRule, str, sortRules, sortByUpdatedAt, sortByPriority, sortByName, sortByCreatedAt, simulateSingleRule, simulate, serializeRuleSet, serializeRule, safeParseRule, rule, rollbackToVersion, resetBuilderIds, removeRuleSet2 as removeRuleSet, removeRule2 as removeRule, pruneOldVersions, parseVersioningConfig, parseValidationConfig, parseRule, parseCacheConfig, or, num, mergeRuleSets, measureTimeAsync, measureTime, isConditionGroup, importRules, importFromJson, 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, getDefaultVersioningConfig, getDefaultValidationConfig, getDefaultLogLevel, getDefaultConflictResolution, getDefaultCacheConfig, 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, date, createVersionStore, createRuleValidator, createRule, createNoopCache, createInitialState, createInitialRuleStats, createInitialOptimizerState, createEngine, createCache, conditions, compareVersions, cloneState, cloneRule, clearRules2 as clearRules, checkRuleFieldCoverage, checkIntegrity, buildIndex, bool, batchSimulate, arr, any, and, analyzeRuleSet, analyzeRuleComplexity, analyzeOptimizations, analyzeOperatorUsage, analyzeFieldUsage, analyzeConsequenceUsage, all, addVersion, addRules2 as addRules, addRuleSet2 as addRuleSet, addRule2 as addRule, WhatIfResult, VersioningConfigSchema, VersioningConfig, VersionStore, VersionHistory, ValidationResultSchema, ValidationResult, ValidationOptionsSchema, ValidationOptions, ValidationErrorSchema, ValidationError, ValidationConfigSchema, ValidationConfig, TimingResult, TagIndex, StringOperator, StringCondition, SortOptions, SortField, SortDirection, SimulationResult, SimulationContext, SerializedRuleSet, SerializedRule, RuleVersion, RuleStatsSchema, RuleStats, RuleSetSchemaType, RuleSetSchema, RuleSetInput, RuleSetAnalysis, RuleSet, RuleSchemaType, RuleSchema, RuleInput, RuleIndex, RuleFilters, RuleEvaluationResult, RuleComplexity, RuleBuilderState, RuleBuilder, Rule, ResolvedValidationOptions, ResolvedEngineConfig, PriorityIndex, OrphanedReference, OptimizerState, OptimizationSuggestion, OperatorUsage, NumberOperator, NumberCondition, LogicalOperator, Logger, LogLevelSchema, LogLevel, IntegrityIssue, IntegrityCheckResult, IntegrityCheckOptions, InferConsequenceType, InferConsequencePayload, IndexOptions, ImportResult, ImportOptions, GroupedRules, GroupEvaluationResult2 as GroupEvaluationResult, GroupByField, FieldUsage, FieldIndex, ExportFormat, EvaluationResult, EvaluationContext, EvaluateRulesResult, EvaluateRulesOptions, EvaluateRuleOptions, EvaluateOptionsSchema, EvaluateOptions, EvaluateConfigSchema, EvaluateConfig, EngineStatsSchema, EngineStats, EngineState, EngineHooks, EngineExecutionResult, EngineConfig, Engine, DefaultConsequences, DateOperator, DateCondition, CustomCondition, ConsequenceUsage, ConsequenceInput, ConsequenceDefinitions, Consequence, ConflictType, ConflictResolutionStrategySchema, ConflictResolutionStrategy, ConflictDetectionOptions, Conflict, ConditionGroup7 as ConditionGroupSchema, ConditionGroup6 as ConditionGroup, ConditionBuilderState, ConditionBuilder, Condition3 as Condition, CategoryIndex, CacheStatsSchema, CacheStats, CacheOptions, CacheEntry, CacheConfigSchema, CacheConfig, Cache, BooleanOperator, BooleanCondition, BatchSimulationResult, ArrayOperator, ArrayCondition, AggregatedConsequence };