rulit 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,745 @@
+import { ZodType } from 'zod';
+
+type ConditionTrace$1 = {
+    label: string;
+    result: boolean;
+    left?: unknown;
+    op?: string;
+    right?: unknown;
+    children?: ConditionTrace$1[];
+    reasonCode?: string;
+};
+type ConditionMeta$1<Facts> = {
+    label: string;
+    reasonCode?: string;
+    kind?: "atomic" | "and" | "or" | "not";
+    children?: Condition$1<Facts>[];
+};
+type RuleTrace$1 = {
+    ruleId: string;
+    matched: boolean;
+    conditions: ConditionTrace$1[];
+    notes: string[];
+    durationMs?: number;
+    error?: string;
+    meta?: RuleMeta$1;
+    skippedReason?: string;
+};
+type Condition$1<Facts> = ((facts: Facts) => ConditionTrace$1) & {
+    meta?: ConditionMeta$1<Facts>;
+};
+type ActionContext$1<Facts, Effects> = {
+    facts: Facts;
+    effects: Effects;
+    trace: {
+        note: (message: string) => void;
+    };
+};
+type RuleActivation$1 = "all" | "first";
+type RuleMeta$1 = {
+    tags?: string[];
+    description?: string;
+    version?: string;
+    reasonCode?: string;
+    enabled?: boolean;
+};
+type EffectsMode$1 = "mutable" | "immutable";
+type MergeStrategy$1 = "assign" | "deep";
+type RunOptions$1 = {
+    activation?: RuleActivation$1;
+    effectsMode?: EffectsMode$1;
+    mergeStrategy?: MergeStrategy$1;
+    rollbackOnError?: boolean;
+    includeTags?: string[];
+    excludeTags?: string[];
+};
+type GraphNode$1 = {
+    id: string;
+    type: "ruleset" | "rule" | "condition";
+    label: string;
+    reasonCode?: string;
+    tags?: string[];
+    description?: string;
+    version?: string;
+};
+type GraphEdge$1 = {
+    from: string;
+    to: string;
+};
+type RulesetGraph$1 = {
+    nodes: GraphNode$1[];
+    edges: GraphEdge$1[];
+};
+type RunResult$1<Effects> = {
+    effects: Effects;
+    fired: string[];
+    trace: RuleTrace$1[];
+    explain: () => string;
+};
+type TraceRun$1 = {
+    id: string;
+    createdAt: number;
+    facts: unknown;
+    fired: string[];
+    trace: RuleTrace$1[];
+};
+type TelemetryAttributes$1 = Record<string, unknown>;
+type TelemetrySpan = {
+    end: () => void;
+    recordException?: (error: unknown) => void;
+    setAttribute?: (key: string, value: unknown) => void;
+    setAttributes?: (attributes: TelemetryAttributes$1) => void;
+};
+type TelemetryAdapter$1 = {
+    startSpan: (name: string, attributes?: TelemetryAttributes$1) => TelemetrySpan;
+};
+type ActionResult<Effects> = void | Partial<Effects>;
+type AsyncActionResult<Effects> = ActionResult<Effects> | Promise<ActionResult<Effects>>;
+
+type Primitive = string | number | boolean | bigint | symbol | null | undefined;
+type DotPrefix<T extends string> = T extends "" ? "" : `.${T}`;
+type PathImpl<T, Key extends keyof T> = Key extends string ? T[Key] extends Primitive ? Key : T[Key] extends Array<unknown> ? Key : T[Key] extends Date ? Key : Key | `${Key}${DotPrefix<Path$1<T[Key]>>}` : never;
+type Path$1<T> = T extends object ? {
+    [K in keyof T]-?: PathImpl<T, K>;
+}[keyof T] : never;
+type PathValue$1<T, P extends Path$1<T>> = P extends `${infer Key}.${infer Rest}` ? Key extends keyof T ? Rest extends Path$1<T[Key]> ? PathValue$1<T[Key], Rest> : never : never : P extends keyof T ? T[P] : never;
+type FieldOperators<T, P extends Path$1<T>> = PathValue$1<T, P> extends number ? NumberOperators<T, P> : PathValue$1<T, P> extends string ? StringOperators<T, P> : PathValue$1<T, P> extends boolean ? BooleanOperators<T, P> : PathValue$1<T, P> extends Date ? DateOperators<T, P> : PathValue$1<T, P> extends Array<infer U> ? ArrayOperators<T, P, U> : BaseOperators<T, P>;
+type BaseOperators<T, P extends Path$1<T>> = {
+    eq: (value: PathValue$1<T, P>) => Condition$1<T>;
+    in: (values: PathValue$1<T, P>[]) => Condition$1<T>;
+};
+type NumberOperators<T, P extends Path$1<T>> = BaseOperators<T, P> & {
+    gt: (value: number) => Condition$1<T>;
+    gte: (value: number) => Condition$1<T>;
+    lt: (value: number) => Condition$1<T>;
+    lte: (value: number) => Condition$1<T>;
+    between: (min: number, max: number) => Condition$1<T>;
+};
+type StringOperators<T, P extends Path$1<T>> = BaseOperators<T, P> & {
+    contains: (value: string) => Condition$1<T>;
+    startsWith: (value: string) => Condition$1<T>;
+    matches: (value: RegExp) => Condition$1<T>;
+};
+type BooleanOperators<T, P extends Path$1<T>> = BaseOperators<T, P> & {
+    isTrue: () => Condition$1<T>;
+    isFalse: () => Condition$1<T>;
+};
+type DateOperators<T, P extends Path$1<T>> = BaseOperators<T, P> & {
+    before: (value: Date) => Condition$1<T>;
+    after: (value: Date) => Condition$1<T>;
+};
+type ArrayOperators<T, P extends Path$1<T>, U> = BaseOperators<T, P> & {
+    contains: (value: U) => Condition$1<T>;
+    any: (predicate: (item: U) => boolean, label?: string) => Condition$1<T>;
+    all: (predicate: (item: U) => boolean, label?: string) => Condition$1<T>;
+};
+type Field$1<T, P extends Path$1<T>> = {
+    path: P;
+    get: (facts: T) => PathValue$1<T, P>;
+} & FieldOperators<T, P>;
+/**
+ * Create a typed field accessor for a facts model.
+ *
+ * @example
+ * ```ts
+ * const factsField = Rules.field<Facts>();
+ * const isAdult = factsField("user.age").gte(18);
+ * ```
+ */
+declare function field<T>(): <P extends Path$1<T>>(path: P) => Field$1<T, P>;
+/**
+ * Create a typed field accessor for a specific path.
+ *
+ * @example
+ * ```ts
+ * const isVip = Rules.field<Facts>()("user.tags").contains("vip");
+ * ```
+ */
+declare function field<T, P extends Path$1<T>>(path: P): Field$1<T, P>;
+
+type ConditionDetails<Facts> = (facts: Facts) => Pick<ConditionTrace$1, "left" | "op" | "right">;
+type ConditionOptions<Facts> = {
+    details?: ConditionDetails<Facts>;
+    reasonCode?: string;
+};
+/**
+ * Create a condition with optional trace details and a reason code.
+ *
+ * @example
+ * ```ts
+ * const isAdult = Rules.condition("is adult", (facts: Facts) => facts.user.age >= 18, {
+ *   details: (facts) => ({ left: facts.user.age, op: ">=", right: 18 }),
+ *   reasonCode: "AGE_18",
+ * });
+ * ```
+ */
+declare function condition<Facts>(label: string, test: (facts: Facts) => boolean, options?: ConditionDetails<Facts> | ConditionOptions<Facts>): Condition$1<Facts>;
+
+type ConditionLabel = string | {
+    label: string;
+};
+/**
+ * Boolean and extensibility operators for composing conditions.
+ */
+declare const op: {
+    and: typeof and;
+    or: typeof or;
+    not: typeof not;
+    custom: typeof custom;
+    register: typeof register;
+    use: typeof use;
+    has: typeof has;
+    list: typeof list;
+};
+type OperatorFactory<Facts, Args extends unknown[]> = (...args: Args) => Condition$1<Facts>;
+/**
+ * Combine conditions with logical AND.
+ *
+ * @example
+ * ```ts
+ * const combined = Rules.op.and(isAdult, isVip);
+ * ```
+ */
+declare function and<Facts>(...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+declare function and<Facts>(label: ConditionLabel, ...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+/**
+ * Combine conditions with logical OR.
+ *
+ * @example
+ * ```ts
+ * const combined = Rules.op.or(isAdult, isVip);
+ * ```
+ */
+declare function or<Facts>(...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+declare function or<Facts>(label: ConditionLabel, ...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+/**
+ * Negate a condition.
+ *
+ * @example
+ * ```ts
+ * const notVip = Rules.op.not(isVip);
+ * ```
+ */
+declare function not<Facts>(conditionToNegate: Condition$1<Facts>): Condition$1<Facts>;
+declare function not<Facts>(label: ConditionLabel, conditionToNegate: Condition$1<Facts>): Condition$1<Facts>;
+/**
+ * Create a custom condition with an optional reason code and trace details.
+ *
+ * @example
+ * ```ts
+ * const isEven = Rules.op.custom("is-even", (facts: { value: number }) => facts.value % 2 === 0);
+ * ```
+ */
+declare function custom<Facts>(label: string, test: (facts: Facts) => boolean, options?: ((facts: Facts) => Pick<ConditionTrace$1, "left" | "op" | "right">) | {
+    details?: (facts: Facts) => Pick<ConditionTrace$1, "left" | "op" | "right">;
+    reasonCode?: string;
+}): Condition$1<Facts>;
+/**
+ * Register a custom operator factory by name.
+ *
+ * @example
+ * ```ts
+ * Rules.op.register("positive", () => Rules.condition("positive", (facts: { value: number }) => facts.value > 0));
+ * ```
+ */
+declare function register<Facts, Args extends unknown[]>(name: string, factory: OperatorFactory<Facts, Args>): void;
+/**
+ * Create a condition using a registered operator.
+ *
+ * @example
+ * ```ts
+ * const positive = Rules.op.use<{ value: number }, []>("positive");
+ * ```
+ */
+declare function use<Facts, Args extends unknown[]>(name: string, ...args: Args): Condition$1<Facts>;
+/**
+ * Check if a custom operator name is registered.
+ *
+ * @example
+ * ```ts
+ * if (!Rules.op.has("positive")) { ... }
+ * ```
+ */
+declare function has(name: string): boolean;
+/**
+ * List registered operator names.
+ *
+ * @example
+ * ```ts
+ * const names = Rules.op.list();
+ * ```
+ */
+declare function list(): string[];
+
+type Rule<Facts, Effects> = {
+    id: string;
+    priority: number;
+    order: number;
+    conditions: Condition$1<Facts>[];
+    action: (ctx: ActionContext$1<Facts, Effects>) => AsyncActionResult<Effects>;
+    meta?: RuleMeta$1;
+};
+type DefaultEffectsFactory<Effects> = () => Effects;
+type Engine<Facts, Effects> = {
+    run: (input: {
+        facts: Facts;
+    } & RunOptions$1) => RunResult$1<Effects>;
+    runAsync: (input: {
+        facts: Facts;
+    } & RunOptions$1) => Promise<RunResult$1<Effects>>;
+};
+type RulesetBuilderWithDefaults<Facts, Effects> = RulesetBuilderImpl<Facts, Effects, true>;
+type RulesetBuilder<Facts, Effects, HasDefaults extends boolean> = Omit<RulesetBuilderImpl<Facts, Effects, HasDefaults>, "compile"> & (HasDefaults extends true ? {
+    compile(): Engine<Facts, Effects>;
+} : {
+    compile: never;
+});
+type RuleBuilder<Facts, Effects, HasDefaults extends boolean, HasThen extends boolean> = Omit<RuleBuilderImpl<Facts, Effects, HasDefaults, HasThen>, "end"> & (HasThen extends true ? {
+    end(): RulesetBuilder<Facts, Effects, HasDefaults>;
+} : {
+    end: never;
+});
+declare class RulesetBuilderImpl<Facts, Effects, HasDefaults extends boolean> {
+    private readonly name?;
+    private readonly rules;
+    private defaultEffectsFactory?;
+    private validateFactsFn?;
+    private validateEffectsFn?;
+    private nextOrder;
+    private registryId?;
+    private telemetryAdapter?;
+    constructor(name?: string);
+    /**
+     * Set the default effects factory. Required before compile().
+     *
+     * @example
+     * ```ts
+     * const rs = Rules.ruleset<Facts, Effects>("rs")
+     *   .defaultEffects(() => ({ flags: [] }));
+     * ```
+     */
+    defaultEffects(factory: DefaultEffectsFactory<Effects>): RulesetBuilder<Facts, Effects, true>;
+    /**
+     * Provide a validation function for facts. Called before each run.
+     *
+     * @example
+     * ```ts
+     * const rs = Rules.ruleset<Facts, Effects>("validate")
+     *   .validateFacts((facts) => {
+     *     if (!facts.user) throw new Error("missing user");
+     *   });
+     * ```
+     */
+    validateFacts(validator: (facts: Facts) => void): RulesetBuilder<Facts, Effects, HasDefaults>;
+    /**
+     * Provide a validation function for effects. Called after default effects creation
+     * and after each run completes.
+     *
+     * @example
+     * ```ts
+     * const rs = Rules.ruleset<Facts, Effects>("validate")
+     *   .validateEffects((effects) => {
+     *     if (!Array.isArray(effects.flags)) throw new Error("invalid effects");
+     *   });
+     * ```
+     */
+    validateEffects(validator: (effects: Effects) => void): RulesetBuilder<Facts, Effects, HasDefaults>;
+    /**
+     * Attach telemetry adapter (OpenTelemetry-compatible).
+     *
+     * @example
+     * ```ts
+     * const adapter = Rules.otel.createAdapter(trace.getTracer("rulit"));
+     * Rules.ruleset("rs").telemetry(adapter);
+     * ```
+     */
+    telemetry(adapter: TelemetryAdapter$1): RulesetBuilder<Facts, Effects, HasDefaults>;
+    _setRegistryId(id: string): void;
+    /**
+     * Add a new rule to the ruleset.
+     *
+     * @example
+     * ```ts
+     * Rules.ruleset<Facts, Effects>("rs")
+     *   .defaultEffects(() => ({ flags: [] }))
+     *   .rule("vip")
+     *   .when(factsField("user.tags").contains("vip"))
+     *   .then(({ effects }) => effects.flags.push("vip"))
+     *   .end();
+     * ```
+     */
+    rule(id: string): RuleBuilder<Facts, Effects, HasDefaults, false>;
+    /**
+     * Create a typed field helper bound to the facts type.
+     *
+     * @example
+     * ```ts
+     * const factsField = Rules.ruleset<Facts, Effects>("rs").field();
+     * const isAdult = factsField("user.age").gte(18);
+     * ```
+     */
+    field(): <P extends Path$1<Facts>>(path: P) => Field$1<Facts, P>;
+    _addRule(rule: Rule<Facts, Effects>): void;
+    _nextOrder(): number;
+    /**
+     * Export a graph representation of the ruleset.
+     *
+     * @example
+     * ```ts
+     * const graph = ruleset.graph();
+     * ```
+     */
+    graph(): RulesetGraph$1;
+    /**
+     * Export a Mermaid flowchart for visualization.
+     *
+     * @example
+     * ```ts
+     * const mermaid = ruleset.toMermaid();
+     * ```
+     */
+    toMermaid(): string;
+    /**
+     * Compile the ruleset into an engine.
+     *
+     * @example
+     * ```ts
+     * const engine = Rules.ruleset<Facts, Effects>("rs")
+     *   .defaultEffects(() => ({ flags: [] }))
+     *   .compile();
+     * ```
+     */
+    compile(this: RulesetBuilderWithDefaults<Facts, Effects>): Engine<Facts, Effects>;
+}
+declare class RuleBuilderImpl<Facts, Effects, HasDefaults extends boolean, HasThen extends boolean> {
+    private readonly ruleset;
+    private readonly id;
+    private priorityValue;
+    private conditions;
+    private action?;
+    private metaValue;
+    constructor(ruleset: RulesetBuilderImpl<Facts, Effects, HasDefaults>, id: string);
+    /**
+     * Set rule priority. Higher runs first.
+     *
+     * @example
+     * ```ts
+     * rule.priority(100);
+     * ```
+     */
+    priority(value: number): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Add conditions to a rule.
+     *
+     * @example
+     * ```ts
+     * rule.when(factsField("user.age").gte(18), factsField("user.tags").contains("vip"));
+     * ```
+     */
+    when(...conditions: Condition$1<Facts>[]): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Set rule metadata in one call.
+     *
+     * @example
+     * ```ts
+     * rule.meta({ tags: ["vip"], version: "1.0.0", reasonCode: "VIP_RULE" });
+     * ```
+     */
+    meta(meta: RuleMeta$1): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Set rule tags used for filtering.
+     *
+     * @example
+     * ```ts
+     * rule.tags("vip", "adult");
+     * ```
+     */
+    tags(...tags: string[]): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Set a human-readable description.
+     *
+     * @example
+     * ```ts
+     * rule.description("VIP adult rule");
+     * ```
+     */
+    description(description: string): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Set a rule version string.
+     *
+     * @example
+     * ```ts
+     * rule.version("1.2.3");
+     * ```
+     */
+    version(version: string): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Set a reason code for audit/explain output.
+     *
+     * @example
+     * ```ts
+     * rule.reasonCode("VIP_ADULT");
+     * ```
+     */
+    reasonCode(reasonCode: string): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Enable or disable a rule.
+     *
+     * @example
+     * ```ts
+     * rule.enabled(false);
+     * ```
+     */
+    enabled(enabled: boolean): RuleBuilder<Facts, Effects, HasDefaults, HasThen>;
+    /**
+     * Set the rule action. Returning a partial effects object applies a patch.
+     *
+     * @example
+     * ```ts
+     * rule.then(({ effects }) => {
+     *   effects.flags.push("vip");
+     * });
+     * ```
+     */
+    then(action: (ctx: ActionContext$1<Facts, Effects>) => ActionResult<Effects>): RuleBuilder<Facts, Effects, HasDefaults, true>;
+    /**
+     * Set an async rule action. Returning a partial effects object applies a patch.
+     *
+     * @example
+     * ```ts
+     * rule.thenAsync(async ({ effects }) => {
+     *   effects.flags.push("vip");
+     * });
+     * ```
+     */
+    thenAsync(action: (ctx: ActionContext$1<Facts, Effects>) => Promise<ActionResult<Effects>>): RuleBuilder<Facts, Effects, HasDefaults, true>;
+    /**
+     * Finalize the rule and return to the ruleset builder.
+     *
+     * @example
+     * ```ts
+     * ruleset.rule("vip").then(() => undefined).end();
+     * ```
+     */
+    end(this: RuleBuilderImpl<Facts, Effects, HasDefaults, true>): RulesetBuilder<Facts, Effects, HasDefaults>;
+}
+/**
+ * Create a new ruleset builder.
+ *
+ * @example
+ * ```ts
+ * const rs = Rules.ruleset<Facts, Effects>("eligibility");
+ * ```
+ */
+declare function ruleset<Facts, Effects>(name?: string): RulesetBuilder<Facts, Effects, false>;
+
+/**
+ * Create a facts validator using a Zod schema.
+ *
+ * @example
+ * ```ts
+ * const factsSchema = z.object({ user: z.object({ age: z.number() }) });
+ * const rs = Rules.ruleset<Facts, Effects>("rs").validateFacts(Rules.zodFacts(factsSchema));
+ * ```
+ */
+declare function zodFacts<Facts>(schema: ZodType<Facts>): (facts: Facts) => void;
+/**
+ * Create an effects validator using a Zod schema.
+ *
+ * @example
+ * ```ts
+ * const effectsSchema = z.object({ flags: z.array(z.string()) });
+ * const rs = Rules.ruleset<Facts, Effects>("rs").validateEffects(Rules.zodEffects(effectsSchema));
+ * ```
+ */
+declare function zodEffects<Effects>(schema: ZodType<Effects>): (effects: Effects) => void;
+
+type GraphSource = {
+    graph: () => RulesetGraph$1;
+    toMermaid: () => string;
+};
+type RegistryListItem = {
+    id: string;
+    name?: string;
+    createdAt: number;
+};
+/**
+ * In-memory registry of rulesets created in this process.
+ */
+declare const registry: {
+    /**
+     * Register a ruleset in the global registry.
+     *
+     * @example
+     * ```ts
+     * const rs = Rules.ruleset<Facts, Effects>("eligibility");
+     * Rules.registry.list();
+     * ```
+     */
+    register(source: GraphSource, name?: string): string;
+    /**
+     * List all registered rulesets.
+     *
+     * @example
+     * ```ts
+     * const list = Rules.registry.list();
+     * ```
+     */
+    list(): RegistryListItem[];
+    /**
+     * Get a graph by id or ruleset name.
+     *
+     * @example
+     * ```ts
+     * const graph = Rules.registry.getGraph("eligibility");
+     * ```
+     */
+    getGraph(idOrName: string): RulesetGraph$1 | undefined;
+    /**
+     * Get Mermaid output by id or ruleset name.
+     *
+     * @example
+     * ```ts
+     * const mermaid = Rules.registry.getMermaid("eligibility");
+     * ```
+     */
+    getMermaid(idOrName: string): string | undefined;
+    /**
+     * Record a trace run for a ruleset. Keeps a rolling window of traces.
+     *
+     * @example
+     * ```ts
+     * Rules.registry.recordTrace("eligibility", trace, fired);
+     * ```
+     */
+    recordTrace(idOrName: string, trace: RuleTrace$1[], fired: string[], facts: unknown): TraceRun$1 | undefined;
+    /**
+     * List trace runs for a ruleset.
+     *
+     * @example
+     * ```ts
+     * const traces = Rules.registry.listTraces("eligibility");
+     * ```
+     */
+    listTraces(idOrName: string): TraceRun$1[];
+    /**
+     * Get a trace by id for a ruleset.
+     *
+     * @example
+     * ```ts
+     * const trace = Rules.registry.getTrace("eligibility", "trace-0");
+     * ```
+     */
+    getTrace(idOrName: string, traceId: string): TraceRun$1 | undefined;
+    /**
+     * Clear the registry (useful in tests).
+     *
+     * @example
+     * ```ts
+     * Rules.registry.clear();
+     * ```
+     */
+    clear(): void;
+};
+
+type OtelSpanLike = {
+    end: () => void;
+    recordException?: (error: unknown) => void;
+    setAttribute?: (key: string, value: unknown) => void;
+    setAttributes?: (attributes: Record<string, unknown>) => void;
+};
+type OtelTracerLike = {
+    startSpan: (name: string, options?: {
+        attributes?: Record<string, unknown>;
+    }) => OtelSpanLike;
+};
+/**
+ * Create a telemetry adapter from an OpenTelemetry tracer.
+ *
+ * @example
+ * ```ts
+ * import { trace } from "@opentelemetry/api";
+ * const adapter = Rules.otel.createAdapter(trace.getTracer("rulit"));
+ * Rules.ruleset("rs").telemetry(adapter);
+ * ```
+ */
+declare function createOtelAdapter(tracer: OtelTracerLike): TelemetryAdapter$1;
+
+declare const Rules: {
+    ruleset: typeof ruleset;
+    condition: typeof condition;
+    field: typeof field;
+    op: {
+        and: {
+            <Facts>(...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+            <Facts>(label: string | {
+                label: string;
+            }, ...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+        };
+        or: {
+            <Facts>(...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+            <Facts>(label: string | {
+                label: string;
+            }, ...conditions: Condition$1<Facts>[]): Condition$1<Facts>;
+        };
+        not: {
+            <Facts>(conditionToNegate: Condition$1<Facts>): Condition$1<Facts>;
+            <Facts>(label: string | {
+                label: string;
+            }, conditionToNegate: Condition$1<Facts>): Condition$1<Facts>;
+        };
+        custom: <Facts>(label: string, test: (facts: Facts) => boolean, options?: ((facts: Facts) => Pick<ConditionTrace$1, "left" | "op" | "right">) | {
+            details?: (facts: Facts) => Pick<ConditionTrace$1, "left" | "op" | "right">;
+            reasonCode?: string;
+        }) => Condition$1<Facts>;
+        register: <Facts, Args extends unknown[]>(name: string, factory: (...args: Args) => Condition$1<Facts>) => void;
+        use: <Facts, Args extends unknown[]>(name: string, ...args: Args) => Condition$1<Facts>;
+        has: (name: string) => boolean;
+        list: () => string[];
+    };
+    registry: {
+        register(source: {
+            graph: () => RulesetGraph$1;
+            toMermaid: () => string;
+        }, name?: string): string;
+        list(): {
+            id: string;
+            name?: string;
+            createdAt: number;
+        }[];
+        getGraph(idOrName: string): RulesetGraph$1 | undefined;
+        getMermaid(idOrName: string): string | undefined;
+        recordTrace(idOrName: string, trace: RuleTrace$1[], fired: string[], facts: unknown): TraceRun$1 | undefined;
+        listTraces(idOrName: string): TraceRun$1[];
+        getTrace(idOrName: string, traceId: string): TraceRun$1 | undefined;
+        clear(): void;
+    };
+    zodFacts: typeof zodFacts;
+    zodEffects: typeof zodEffects;
+    otel: {
+        createAdapter: typeof createOtelAdapter;
+    };
+};
+
+type ActionContext<Facts, Effects> = ActionContext$1<Facts, Effects>;
+type Condition<Facts> = Condition$1<Facts>;
+type ConditionMeta<Facts> = ConditionMeta$1<Facts>;
+type ConditionTrace = ConditionTrace$1;
+type EffectsMode = EffectsMode$1;
+type MergeStrategy = MergeStrategy$1;
+type RuleActivation = RuleActivation$1;
+type RuleMeta = RuleMeta$1;
+type RulesetGraph = RulesetGraph$1;
+type GraphNode = GraphNode$1;
+type GraphEdge = GraphEdge$1;
+type RuleTrace = RuleTrace$1;
+type RunOptions = RunOptions$1;
+type RunResult<Effects> = RunResult$1<Effects>;
+type TraceRun = TraceRun$1;
+type TelemetryAdapter = TelemetryAdapter$1;
+type TelemetryAttributes = TelemetryAttributes$1;
+type Field<T, P extends Path$1<T>> = Field$1<T, P>;
+type Path<T> = Path$1<T>;
+type PathValue<T, P extends Path$1<T>> = PathValue$1<T, P>;
+
+export { type ActionContext, type Condition, type ConditionMeta, type ConditionTrace, type EffectsMode, type Field, type GraphEdge, type GraphNode, type MergeStrategy, type Path, type PathValue, type RuleActivation, type RuleMeta, type RuleTrace, Rules, type RulesetGraph, type RunOptions, type RunResult, type TelemetryAdapter, type TelemetryAttributes, type TraceRun, condition, createOtelAdapter, field, op, registry, ruleset, zodEffects, zodFacts };