@inixiative/json-rules 2.27.0 → 3.0.1

package/dist/index.d.cts

@@ -18,7 +18,9 @@ declare const Operator: {
     readonly exists: "exists";
     readonly notExists: "notExists";
     readonly startsWith: "startsWith";
+    readonly notStartsWith: "notStartsWith";
     readonly endsWith: "endsWith";
+    readonly notEndsWith: "notEndsWith";
 };
 type Operator = (typeof Operator)[keyof typeof Operator];
 declare const ArrayOperator: {
@@ -48,12 +50,95 @@ declare const DateOperator: {
 };
 type DateOperator = (typeof DateOperator)[keyof typeof DateOperator];
 
+/** A selectable option — the standard `<select>` shape: a value with an optional display
+ * label, plus the partition keys (index-aligned with the source's `groupBy` axes)
+ * when the source is grouped. */
+type SourceOption = {
+    value: string;
+    label?: string;
+    groups?: string[];
+};
+type FieldMapEntry = {
+    kind: 'scalar' | 'object' | 'enum' | 'bridge';
+    type: string;
+    isList?: boolean;
+    /**
+     * Whether the column is NOT NULL. `toPrisma` reads this to decide if a negated
+     * operator needs an explicit `equals: null` arm (Prisma's `not`/`notIn` follow SQL
+     * three-valued logic and drop NULL rows); absent = unknown = no arm.
+     */
+    isRequired?: boolean;
+    fromFields?: string[];
+    toFields?: string[];
+    relationName?: string;
+    /**
+     * Per-field allowed values, primarily for enum fields. Takes precedence over
+     * `FieldMap.enums[type]` if both are set. Pass-through from codegen
+     * (e.g. prisma-map's `EnumField.values`). Consumed by `validateRuleInLens`.
+     */
+    values?: readonly string[];
+    /**
+     * A field's selectable option set as `{ value, label? }` pairs — the display
+     * shape a picker consumes. On projection/surface output this is populated for
+     * every value-gated field (enum members normalized to `{ value, label: value }`)
+     * and for sourced fields (the fetched pairs from a materialized `SourceValues`).
+     */
+    options?: readonly SourceOption[];
+    /**
+     * Present on projection/surface output when the field's source partitions its
+     * options: the dotted to-one axes (relative to this model) whose values are
+     * each option's `groups`, index-aligned.
+     */
+    groupBy?: readonly string[];
+};
+type ModelEntry = {
+    dbName?: string | null;
+    fields: Record<string, FieldMapEntry>;
+};
+/**
+ * A schema map: models keyed by name, plus an optional enum registry scoped to
+ * this source. In multi-source setups (Prisma + Salesforce + CRM) each FieldMap
+ * carries its own enums so namespaces don't collide across sources.
+ */
+type FieldMap = {
+    models: Record<string, ModelEntry>;
+    /** Enum name → allowed values, e.g. `{ UserRole: ['ADMIN', 'USER'] }`. */
+    enums?: Record<string, readonly string[]>;
+};
+type BridgeEndpoint = {
+    fieldMap: string;
+    model: string;
+    on: string;
+};
+type BridgeCardinality = 'oneToOne' | 'oneToMany';
+/**
+ * A cross-source edge between two endpoints.
+ *
+ * Endpoint ordering convention for `oneToMany`:
+ *   - `endpoints[0]` is the "one" side — its `on` field must be unique per row
+ *     (typically a primary key).
+ *   - `endpoints[1]` is the "many" side — its `on` field may repeat across rows
+ *     (typically a foreign key).
+ *
+ * Mis-ordering produces wrong `isList` flags during stitching and silent
+ * row-dedup when building bridge dictionaries. `indexBridges` throws
+ * at runtime if endpoint[0]'s data has duplicate `on` values to catch this.
+ *
+ * For `oneToOne`, both `on` fields must be unique; endpoint order is symmetric.
+ */
+type Bridge = {
+    endpoints: [BridgeEndpoint, BridgeEndpoint];
+    cardinality: BridgeCardinality;
+};
+type FieldMapSet = {
+    maps: Record<string, FieldMap>;
+    bridges?: Bridge[];
+};
+
 type FuzzyConfig = {
     maxDistance?: number;
     maxRatio?: number;
 };
-declare const maxFuzzyDistance: (length: number) => number;
-declare const fuzzyContains: (haystack: string, query: string, config?: FuzzyConfig) => boolean;
 
 declare const FieldKind: {
     readonly String: "String";
@@ -69,11 +154,7 @@ declare const FieldKind: {
 };
 type FieldKind = (typeof FieldKind)[keyof typeof FieldKind];
 declare const NUMERIC_KINDS: readonly FieldKind[];
-declare const ORDERABLE_KINDS: readonly FieldKind[];
-declare const STRINGY_KINDS: readonly FieldKind[];
-declare const EQUATABLE_KINDS: readonly FieldKind[];
 declare const ALL_KINDS: readonly FieldKind[];
-declare const NULLABLE_KINDS: readonly FieldKind[];
 declare const RuleTarget: {
     readonly check: "check";
     readonly toPrisma: "toPrisma";
@@ -96,139 +177,15 @@ declare const ValueShape: {
     readonly predicate: "predicate";
 };
 type ValueShape = (typeof ValueShape)[keyof typeof ValueShape];
-type CatalogEntry = {
-    kinds: readonly FieldKind[];
-    targets: readonly RuleTarget[];
-    valueShape: ValueShape;
-    acceptsExpr?: boolean;
-};
-declare const FIELD_OPERATOR_CATALOG: Record<Operator, CatalogEntry>;
-declare const DATE_OPERATOR_CATALOG: Record<DateOperator, CatalogEntry>;
-type ArrayCatalogEntry = {
-    targets: readonly RuleTarget[];
-    valueShape: ValueShape;
-};
-declare const ARRAY_OPERATOR_CATALOG: Record<ArrayOperator, ArrayCatalogEntry>;
-declare const WindowSupport: {
-    readonly full: "full";
-    readonly extremal: "extremal";
-    readonly none: "none";
-};
-type WindowSupport = (typeof WindowSupport)[keyof typeof WindowSupport];
-declare const WINDOW_SELECTOR: {
-    readonly fields: readonly ["filter", "orderBy", "take", "skip"];
-    readonly sortDirs: readonly ["asc", "desc"];
-    readonly support: {
-        readonly array: {
-            readonly check: "full";
-            readonly toPrisma: "extremal";
-            readonly toSql: "none";
-        };
-        readonly aggregate: {
-            readonly check: "full";
-            readonly toPrisma: "none";
-            readonly toSql: "none";
-        };
-    };
-};
-type WindowRuleType = keyof typeof WINDOW_SELECTOR.support;
-declare const getWindowSupport: (ruleType: WindowRuleType, target: RuleTarget) => WindowSupport;
-declare const AGGREGATE_OPERATORS: readonly Operator[];
-/** The aggregate threshold comparisons `target` can compile — all of them when no
- *  target is given. The one source for both the validator's rejection and a builder's
- *  threshold picker, so neither has to restate which target drops which operator. */
-declare const getAggregateOperators: (target?: RuleTarget) => readonly Operator[];
-declare const isAggregateSingleOperator: (operator: Operator) => boolean;
-declare const isAggregateRangeOperator: (operator: Operator) => boolean;
-declare const getValueShape: (operator: Operator | DateOperator | ArrayOperator) => ValueShape;
-declare const isOperatorSupportedForTarget: (operator: Operator | DateOperator | ArrayOperator, target: RuleTarget) => boolean;
+/** Which catalog an operator belongs to — `between` is both a field and a date operator. */
+type OperatorFamily = 'field' | 'date' | 'array';
+declare const getValueShape: (operator: string, family: OperatorFamily) => ValueShape;
 declare const getOperatorsForKind: (kind: FieldKind, target?: RuleTarget) => {
     field: Operator[];
     date: DateOperator[];
 };
 declare const getArrayOperators: (target?: RuleTarget) => ArrayOperator[];
-/** Operators that read no comparison value. */
-declare const NO_VALUE_OPERATORS: readonly string[];
-/** Field comparisons with an order: `<`, `<=`, `>`, `>=`. */
-declare const ORDERED_OPERATORS: readonly string[];
-/** A window expression (`within`), not a pair. */
-declare const WINDOW_OPERATORS: readonly string[];
-/** Operators that compare against two ends. */
-declare const RANGE_OPERATORS: readonly string[];
-/** Operators with a point to move: the comparisons and both ends of a pair. */
-declare const OFFSET_OPERATORS: readonly string[];
-/** The negations: each is the complement of its positive form and keeps NULL fields
- *  (the 2.19.0 ruling). */
-declare const NEGATED_OPERATORS: readonly string[];
-/** Negations of a two-ended range. */
-declare const NEGATED_RANGE_OPERATORS: string[];
-/** Negated comparisons an offset can move; with nothing to compare against they still keep a
- *  null field. */
-declare const NEGATED_COMPARISON_OPERATORS: string[];
-/** Negations of one literal (`notEquals`, `notContains`). */
-declare const NEGATED_SINGLE_VALUE_OPERATORS: string[];
-/** Comparisons that bound a field from above / below — what a window's extremal rewrite reads. */
-declare const UPPER_BOUND_OPERATORS: readonly string[];
-declare const LOWER_BOUND_OPERATORS: readonly string[];
-/** Kinds a calendar unit amount can read: whole numbers. */
-declare const INTEGER_KINDS: readonly FieldKind[];
-/** Kinds check() coerces a literal to (see coerceScalar in src/field.ts). */
-declare const COERCIBLE_KINDS: readonly FieldKind[];
-/** Kinds whose literal the compilers coerce exactly as check() does — Prisma rejects a string on
- *  Int/Float/Boolean; BigInt compares as Int. Decimal keeps its literal: Prisma and Postgres take
- *  the numeric string losslessly, and a JS number would not. */
-declare const COMPILE_COERCED_KINDS: readonly FieldKind[];
-/** Value shapes that take one literal. */
-declare const SINGLE_VALUE_SHAPES: readonly ValueShape[];
-/** Each relative unit: the Postgres interval field it adds to, its size there, and whether it is
- *  a calendar unit (whole steps). Applied months, then days, then time, as Postgres does. */
-declare const RELATIVE_UNITS: {
-    readonly years: {
-        readonly interval: "months";
-        readonly factor: 12;
-        readonly calendar: true;
-    };
-    readonly quarters: {
-        readonly interval: "months";
-        readonly factor: 3;
-        readonly calendar: true;
-    };
-    readonly months: {
-        readonly interval: "months";
-        readonly factor: 1;
-        readonly calendar: true;
-    };
-    readonly weeks: {
-        readonly interval: "days";
-        readonly factor: 7;
-        readonly calendar: true;
-    };
-    readonly days: {
-        readonly interval: "days";
-        readonly factor: 1;
-        readonly calendar: true;
-    };
-    readonly hours: {
-        readonly interval: "secs";
-        readonly factor: 3600;
-        readonly calendar: false;
-    };
-    readonly minutes: {
-        readonly interval: "secs";
-        readonly factor: 60;
-        readonly calendar: false;
-    };
-    readonly seconds: {
-        readonly interval: "secs";
-        readonly factor: 1;
-        readonly calendar: false;
-    };
-};
-type RelativeUnit = keyof typeof RELATIVE_UNITS;
-declare const INTERVAL_FIELDS: readonly ["months", "days", "secs"];
-declare const isRelativeUnit: (unit: string) => unit is RelativeUnit;
-declare const isCalendarUnit: (unit: string) => boolean;
-declare const PERIOD_UNITS: readonly string[];
+declare const getAggregateOperators: () => readonly Operator[];
 
 type OperatorValues = typeof Operator;
 type ArrayOperatorValues = typeof ArrayOperator;
@@ -313,7 +270,7 @@ type StrictOrderedComparisonRule = (RuleBase<OperatorValues['lessThan']> & Value
 type StrictMembershipRule<TValue = RuleValue> = (RuleBase<OperatorValues['in']> & ValueSource<TValue[]>) | (RuleBase<OperatorValues['notIn']> & ValueSource<TValue[]>);
 type StrictContainsRule<TValue = RuleValue> = (RuleBase<OperatorValues['contains']> & ValueSource<TValue>) | (RuleBase<OperatorValues['notContains']> & ValueSource<TValue>);
 type StrictPatternRule = (RuleBase<OperatorValues['matches']> & ValueSource<RegExp | string>) | (RuleBase<OperatorValues['notMatches']> & ValueSource<RegExp | string>);
-type StrictStringBoundaryRule = (RuleBase<OperatorValues['startsWith']> & ValueSource<string>) | (RuleBase<OperatorValues['endsWith']> & ValueSource<string>);
+type StrictStringBoundaryRule = (RuleBase<OperatorValues['startsWith']> & ValueSource<string>) | (RuleBase<OperatorValues['notStartsWith']> & ValueSource<string>) | (RuleBase<OperatorValues['endsWith']> & ValueSource<string>) | (RuleBase<OperatorValues['notEndsWith']> & ValueSource<string>);
 type StrictRangeRule = (RuleBase<OperatorValues['between']> & ValueSource<[OrderedRuleValue, OrderedRuleValue], NumberOffset>) | (RuleBase<OperatorValues['notBetween']> & ValueSource<[OrderedRuleValue, OrderedRuleValue], NumberOffset>);
 type StrictPresenceRule = (RuleBase<OperatorValues['isEmpty']> & NoValueSource) | (RuleBase<OperatorValues['notEmpty']> & NoValueSource) | (RuleBase<OperatorValues['exists']> & NoValueSource) | (RuleBase<OperatorValues['notExists']> & NoValueSource);
 type StrictRule<TValue = RuleValue> = StrictEqualityRule<TValue> | StrictOrderedComparisonRule | StrictMembershipRule<TValue> | StrictContainsRule<TValue> | StrictPatternRule | StrictStringBoundaryRule | StrictRangeRule | StrictPresenceRule;
@@ -443,45 +400,36 @@ type StrictIfThenElse<TRuleValue = RuleValue, TDateValue = DateRuleValue> = {
     error?: string;
 };
 type StrictCondition<TRuleValue = RuleValue, TDateValue = DateRuleValue> = StrictRule<TRuleValue> | StrictAggregateRule<TRuleValue, TDateValue> | StrictArrayRule<TRuleValue, TDateValue> | StrictDateRule | StrictAll<TRuleValue, TDateValue> | StrictAny<TRuleValue, TDateValue> | StrictIfThenElse<TRuleValue, TDateValue> | boolean;
+/** A row as a rule reads it: a record of fields. */
+type Row = Record<string, unknown>;
+/** What both compilers take: the schema (a FieldMap, or a FieldMapSet with `mapName`), the
+ *  model the rule reads, the context `$` refs read, and the clock. */
+type CompileOptions = {
+    map?: FieldMap | FieldMapSet;
+    mapName?: string;
+    model?: string;
+    context?: Row;
+} & DateConfig;
+/** What check() evaluates: one row, or a root array of them. */
+type CheckData = Row | unknown[];
 
-type ScopeRef = {
-    depth: number;
-    path: string;
+/** `required`: leave out the names an optional bind (`bindOptional`) may go unsupplied. */
+type ListBindingsOptions = {
+    required?: boolean;
 };
-declare const parseScopeRef: (ref: string) => ScopeRef | null;
-type ScopedRef<S> = {
-    scope: S;
-    path: string;
-};
-type ScopeOutOfBounds = {
-    outOfBounds: string;
-};
-declare const resolveScopeRef: <S>(ref: string, scopes: readonly S[]) => ScopedRef<S> | ScopeOutOfBounds;
-
-/**
- * The value of one `{ bind }` at evaluation. Key presence is the contract: an unsupplied
- * binding is a caller bug (a forgotten scope must never silently run) unless the source marks
- * it `bindOptional`, which reads as null. A supplied-but-undefined binding is null.
- */
-declare const readBinding: (name: string, optional: boolean | undefined, bindings: Record<string, RuleValue> | undefined) => RuleValue;
-
-/** Names of every `{ bind }` token in the tree, optional or not — what a lens declares. */
-declare const bindingNames: (condition: Condition) => Set<string>;
 /**
- * Names a bindings map must cover: every `{ bind }` token not marked `bindOptional`. A
- * name that is optional at one leaf and required at another is required. An optional
- * name left unsupplied evaluates and compiles as `null`.
+ * The bind names a rule reads, sorted. With `required`, only those a bindings map must cover —
+ * not `bindOptional` (unsupplied, it reads null); a name optional at one leaf and required at
+ * another is required.
  */
-declare const requiredBindings: (condition: Condition) => Set<string>;
+declare const listBindings: (condition: Condition, { required }?: ListBindingsOptions) => string[];
 /**
  * Substitute covered binds with their values; uncovered tokens stay in place (partial
  * resolution). A supplied-but-undefined binding becomes null to stay serializable.
  * Non-mutating.
  */
-declare const resolveBindings: (condition: Condition, bindings: Record<string, RuleValue>) => Condition;
+declare const bindRule: (condition: Condition, bindings: Record<string, RuleValue>) => Condition;
 
-type Row$3 = Record<string, unknown>;
-type CheckData = Row$3 | unknown[];
 type CheckOptions = {
     context?: CheckData;
     bindings?: Record<string, RuleValue>;
@@ -498,6 +446,9 @@ type EngineGlobalsState = {
         datasource: {
             provider: PrismaProvider;
         };
+        /** Prisma's `AnyNull` — matches a DB NULL, a JSON null and an absent Json path. Defaults to
+         *  your installed @prisma/client's; set it only to use another. */
+        anyNull?: unknown;
     };
 };
 type DeepPartial<T> = {
@@ -509,137 +460,33 @@ declare const engineGlobals: {
     reset: () => void;
     with: <T>(partial: DeepPartial<EngineGlobalsState>, fn: () => T) => T;
 };
-declare const supportsQueryMode: (provider: PrismaProvider) => boolean;
-declare const resolveCaseInsensitive: (ruleFlag?: boolean) => boolean;
-declare const resolveFuzzy: (ruleFlag?: boolean | FuzzyConfig) => FuzzyConfig | false;
-
-type PrismaWhere = Record<string, unknown>;
-/** A selectable option — the standard `<select>` shape: a value with an optional display
- * label, plus the partition keys (index-aligned with the source's `groupBy` axes)
- * when the source is grouped. */
-type SourceOption = {
-    value: string;
-    label?: string;
-    groups?: string[];
-};
-type FieldMapEntry = {
-    kind: 'scalar' | 'object' | 'enum' | 'bridge';
-    type: string;
-    isList?: boolean;
-    /**
-     * Whether the column is NOT NULL. `toPrisma` reads this to decide if a negated
-     * operator needs an explicit `equals: null` arm (Prisma's `not`/`notIn` follow SQL
-     * three-valued logic and drop NULL rows); absent = unknown = no arm.
-     */
-    isRequired?: boolean;
-    fromFields?: string[];
-    toFields?: string[];
-    relationName?: string;
-    /**
-     * Per-field allowed values, primarily for enum fields. Takes precedence over
-     * `FieldMap.enums[type]` if both are set. Pass-through from codegen
-     * (e.g. prisma-map's `EnumField.values`). Consumed by `checkRuleAgainstLens`.
-     */
-    values?: readonly string[];
-    /**
-     * A field's selectable option set as `{ value, label? }` pairs — the display
-     * shape a picker consumes. On projection/surface output this is populated for
-     * every value-gated field (enum members normalized to `{ value, label: value }`)
-     * and for sourced fields (the fetched pairs from a materialized `SourceValues`).
-     */
-    options?: readonly SourceOption[];
-    /**
-     * Present on projection/surface output when the field's source partitions its
-     * options: the dotted to-one axes (relative to this model) whose values are
-     * each option's `groups`, index-aligned.
-     */
-    groupBy?: readonly string[];
-};
-type ModelEntry = {
-    dbName?: string | null;
-    fields: Record<string, FieldMapEntry>;
-};
-/**
- * A schema map: models keyed by name, plus an optional enum registry scoped to
- * this source. In multi-source setups (Prisma + Salesforce + CRM) each FieldMap
- * carries its own enums so namespaces don't collide across sources.
- */
-type FieldMap = {
-    models: Record<string, ModelEntry>;
-    /** Enum name → allowed values, e.g. `{ UserRole: ['ADMIN', 'USER'] }`. */
-    enums?: Record<string, readonly string[]>;
-};
-type StepRef = {
-    __step: number;
-};
-type GroupByStep = {
-    operation: 'groupBy';
-    model: string;
-    args: {
-        by: string[];
-        where: Record<string, unknown>;
-        having: Record<string, unknown>;
-    };
-    extract: string;
-};
-type WhereStep = {
-    operation: 'where';
-    where: Record<string, unknown>;
-};
-type PrismaStep = GroupByStep | WhereStep;
-type ToPrismaResult = {
-    steps: PrismaStep[];
-};
-type BuildOptions = {
-    map?: FieldMap | FieldMapSet;
-    mapName?: string;
-    model?: string;
-    context?: Record<string, unknown>;
-    datasource?: {
-        provider?: PrismaProvider;
-    };
-} & DateConfig;
-
-type BridgeEndpoint = {
-    fieldMap: string;
-    model: string;
-    on: string;
-};
-type BridgeCardinality = 'oneToOne' | 'oneToMany';
-/**
- * A cross-source edge between two endpoints.
- *
- * Endpoint ordering convention for `oneToMany`:
- *   - `endpoints[0]` is the "one" side — its `on` field must be unique per row
- *     (typically a primary key).
- *   - `endpoints[1]` is the "many" side — its `on` field may repeat across rows
- *     (typically a foreign key).
- *
- * Mis-ordering produces wrong `isList` flags during stitching and silent
- * row-dedup when building bridge dictionaries. `buildBridgeDictionary` throws
- * at runtime if endpoint[0]'s data has duplicate `on` values to catch this.
- *
- * For `oneToOne`, both `on` fields must be unique; endpoint order is symmetric.
- */
-type Bridge = {
-    endpoints: [BridgeEndpoint, BridgeEndpoint];
-    cardinality: BridgeCardinality;
-};
-type FieldMapSet = {
-    maps: Record<string, FieldMap>;
-    bridges?: Bridge[];
-};
 
-type Row$2 = Record<string, unknown>;
 type BridgeDictionary = Record<string, // map name
 Record<string, // model name
-Record<string, Record<string, Row$2 | Row$2[]>>>>;
-declare const buildBridgeDictionary: (set: FieldMapSet, rawData: Record<string, Row$2[]>) => BridgeDictionary;
+Record<string, Record<string, Row | Row[]>>>>;
+declare const indexBridges: (set: FieldMapSet, rawData: Record<string, Row[]>) => BridgeDictionary;
 
 declare const stitchFieldMaps: (set: FieldMapSet) => FieldMapSet;
 
-declare const validateFieldMapSet: (set: FieldMapSet) => void;
-declare const validateFieldMap: (fieldMap: FieldMap, mapName?: string) => void;
+type ValidationIssue = {
+    path: string;
+    message: string;
+    code: string;
+};
+type ValidationResult = {
+    ok: boolean;
+    errors: ValidationIssue[];
+};
+/** Which engine a rule must compile for; `check` (the default) accepts every rule. */
+type ValidateRuleOptions = {
+    target?: RuleTarget;
+};
+declare const validateRule: (condition: unknown, options?: ValidateRuleOptions) => ValidationResult;
+declare const assertValidRule: (condition: unknown, options?: ValidateRuleOptions) => asserts condition is Condition;
+
+/** Field names are plain identifiers: `.` walks a path and `:` names a bridge target. */
+declare const validateFieldMaps: (set: FieldMapSet) => ValidationResult;
+declare const assertValidFieldMaps: (set: FieldMapSet) => void;
 
 type Lens = FieldMapSet & {
     mapName: string;
@@ -653,8 +500,8 @@ type Lens = FieldMapSet & {
  * - SCHEMA narrowing (picks/omits/enumPicks/enumOmits): controls what's visible
  *   in the type surface. AI/SDK consumers can't see narrowed-away fields.
  * - DATA narrowing (where): controls which ROWS are in scope. Filter-first
- *   semantic, anchored to the model. Under arrayOperator: 'all', applied via
- *   implication (negate) to preserve filter-first meaning — see applyLens.
+ *   semantic, anchored to the model. Under arrayOperator: 'all', it becomes the window filter
+ *   (filter-first) — see narrowRule.
  */
 type ModelDefaultNarrowing = {
     picks?: string[];
@@ -677,7 +524,7 @@ type ModelDefaultNarrowing = {
      * model that path resolves to. The `where` composes AND-only across layers (general
      * via `mapDefaults`, path-specific via `root`/`relations`); a later layer's `label` wins.
      */
-    sources?: Record<string, SourceValue>;
+    sources?: Record<string, SourceEntry>;
 };
 /**
  * A sourced field's eligibility `where` plus an optional display-label column — a
@@ -701,7 +548,7 @@ type SourceSpec = {
     groupBy: string | string[];
 };
 /** A `sources` entry: a bare eligibility `Condition`, or a richer `SourceSpec`. */
-type SourceValue = Condition | SourceSpec;
+type SourceEntry = Condition | SourceSpec;
 /** Narrowing for a model at a specific traversal path. Adds relations to the default shape. */
 type ModelNarrowing = ModelDefaultNarrowing & {
     relations?: Record<string, ModelNarrowing>;
@@ -730,8 +577,6 @@ type LensNarrowing = {
     mapDefaults?: Record<string, NarrowingDefaults>;
 };
 
-declare const applyLens: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => Condition;
-
 /**
  * Every bind name a lens (its whole narrowing chain) needs supplied to execute —
  * `bindOptional` tokens are not required (unsupplied, they resolve to null).
@@ -740,29 +585,74 @@ declare const applyLens: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing
  * this lens require" answer; pass `narrowing.parent` to see the names a child must
  * not collide with.
  */
-declare const lensRequiredBindings: (lensOrNarrowing: Lens | LensNarrowing) => Set<string>;
+declare const listLensBindings: (lensOrNarrowing: Lens | LensNarrowing) => string[];
 /**
  * Preprocess a lens: resolve every `{ bind }` token the map covers in the chain's
  * `where`/`sources`, returning a structurally-new lens with concrete conditions.
  * Partial — uncovered tokens stay, so stages bind progressively. Once resolved,
- * `applyLens` / `toPrisma` / `toSql` / `sourceQueries` / `projectByPath` consume the
+ * `narrowRule` / `toPrisma` / `toSql` / `toSourceQueries` / `projectPaths` consume the
  * lens unchanged: a bind needs nothing new downstream. `parent:name` draws the same
  * value as the ancestor's `name`. Does not mutate the input.
  */
-declare const resolveLensBindings: (lensOrNarrowing: Lens | LensNarrowing, bindings: Record<string, RuleValue>) => Lens | LensNarrowing;
+declare const bindLens: (lensOrNarrowing: Lens | LensNarrowing, bindings: Record<string, RuleValue>) => Lens | LensNarrowing;
+
+declare const coerceRule: (condition: Condition, lensOrNarrowing: Lens | LensNarrowing) => Condition;
+
+/** A lens over field maps, its bridges stitched into the maps as fields. */
+declare const createLens: ({ maps, bridges, mapName, model }: Lens) => Lens;
+
+type RuleDescription = {
+    sources: string[];
+    bridgesCrossed: boolean;
+    supportedTargets: RuleTarget[];
+    /** What the lens refuses in the rule — validateRuleInLens's issues. */
+    errors: ValidationIssue[];
+};
+declare const describeRule: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => RuleDescription;
+
 /**
- * Bind names are unique across a composed chain: a layer may not re-declare a name
- * an ancestor already declares — rename it, or reference the inherited one read-only
- * as `parent:name`. A `parent:name` reference must point at a name some ancestor
- * actually declares. Returns the violation messages (folded into `validateNarrowing`).
+ * The values one rule compares at one declared source — keyed the way `projectPaths`
+ * keys a source (`path` + `field`), so the caller can join it back to the source's
+ * model without spelling a path of its own. A `mapDefaults`-declared source resolves
+ * wherever its model appears, so `path` may name a relation chain the narrowing never
+ * spelled under `root.relations`; the dotted format is the same.
  */
-declare const validateBindNames: (narrowing: LensNarrowing) => string[];
+type RuleSourceDescription = {
+    path: string;
+    mapName: string;
+    model: string;
+    field: string;
+    /** Every literal a leaf at this source named; list operators flattened, deduped by content. */
+    values: RuleValue[];
+    /**
+     * The set of values cannot be enumerated from literals: a leaf read a value at evaluation
+     * (a `path` / `bind` on its comparison value, an offset or an amount) or moved it by an offset, used an operator that describes values without naming them
+     * (substring, pattern, range, date window), or used an operator the catalog does not
+     * know. A caller deciding anything from `values` must fail closed.
+     */
+    dynamic: boolean;
+};
+/**
+ * Which values a rule names at each source the lens declares — the lens owns the
+ * vocabulary, so it answers questions about it; callers never spell a path. A leaf reaches a
+ * source by its absolute path through the lens: nested (`{ field: 'orders', arrayOperator,
+ * condition: { field: 'sku' } }`) and dotted (`{ field: 'orders.sku' }`) spellings are one path,
+ * resolved by `lensPathEnd` — visibility, `mapDefaults`, and the Json boundary all apply, so a
+ * source declared in `mapDefaults` answers wherever its model appears. Quantifier-blind on
+ * purpose — a `none` relation names its value as much as an `any` one, `notIn` as much as `in` —
+ * but shape-aware via the operator catalog: only literal-naming shapes contribute `values`;
+ * substring / pattern / range / window operators, and operators the catalog does not know, mark
+ * the source `dynamic` instead of inventing values. A relation node's own comparison (an
+ * aggregate's threshold, an array `count`) belongs to the node, not to a source. Paths invisible
+ * under the lens, unmapped segments, and sub-paths beneath a Json column are silent.
+ */
+declare const describeRuleSources: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => RuleSourceDescription[];
 
 type LensPathHop = {
     field: string;
     entry: FieldMapEntry;
     mapName: string;
-    modelName: string;
+    model: string;
     /** The relation path from the lens anchor to the model this hop reads. */
     relPath: string[];
 };
@@ -783,35 +673,9 @@ type LensPathResolution = {
     hops: LensPathHop[];
 };
 
-type RuleLensViolation = {
-    path: string;
-    reason: string;
-};
-type RuleLensCheck = {
-    ok: boolean;
-    violations: RuleLensViolation[];
-};
-declare const checkRuleAgainstLens: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => RuleLensCheck;
-
-type CreateLensInput = {
-    maps: Record<string, FieldMap>;
-    bridges?: Bridge[];
-    mapName: string;
-    model: string;
-};
-declare const createLens: (input: CreateLensInput) => Lens;
-
-type RuleDescription = {
-    sources: string[];
-    bridgesCrossed: boolean;
-    supportedTargets: RuleTarget[];
-    violations: string[];
-};
-declare const describeRule: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => RuleDescription;
-
 type ProjectedVisit = {
     mapName: string;
-    modelName: string;
+    model: string;
     fields: Record<string, FieldMapEntry>;
     whereClauses: Condition[];
     /** Per-field source eligibility wheres, composed across layers (general + path). */
@@ -822,12 +686,13 @@ type ProjectedVisit = {
     /** Per-field option-partition axes for a sourced field (from a SourceSpec's `groupBy`). */
     sourceGroupBys: Record<string, string[]>;
 };
-type PathProjection = Map<string, ProjectedVisit>;
+/** Each declared path's projected visit, keyed by dotted path from the lens model. */
+type PathProjection = Record<string, ProjectedVisit>;
 /**
  * The materialized option set for one sourced field — the fetched companion to a
  * serializable lens. Its `options` are `{ value, label? }` pairs (the standard
- * `<select>` shape); it feeds both projections: `projectByPath` keys by
- * `path`+`field` (exact), `exposedSurface` by `mapName`+`model`+`field` (union).
+ * `<select>` shape); it feeds both projections: `projectPaths` keys by
+ * `path`+`field` (exact), `projectModels` by `mapName`+`model`+`field` (union).
  */
 type SourceValues = {
     path: string;
@@ -836,61 +701,37 @@ type SourceValues = {
     field: string;
     options: readonly SourceOption[];
 };
-type ProjectOptions = {
+type ProjectLensOptions = {
     sourceValues?: readonly SourceValues[];
 };
-declare const projectByPath: (lensOrNarrowing: Lens | LensNarrowing, opts?: ProjectOptions) => PathProjection;
-
-declare const exposedSurface: (lensOrNarrowing: Lens | LensNarrowing, opts?: ProjectOptions) => Lens;
 
-declare const validateNarrowing: (narrowing: LensNarrowing) => void;
-
-/**
- * Resolve one dotted path through a lens, hop by hop, verifying as it walks: every hop is checked
- * against the narrowing at that visit, so a relation the narrowing dropped is `hidden`, a column the
- * model lacks is `missing`, and a segment past a scalar is `pastScalar`. This is the walk
- * `checkRuleAgainstLens` gates a rule's field with, exposed for consumers that resolve paths of their
- * own (template tokens, loop bindings, presence guards).
- */
-declare const resolveLensPath: (lensOrNarrowing: Lens | LensNarrowing, path: string) => LensPathResolution;
-
-/**
- * The values one rule compares at one declared source — keyed the way `projectByPath`
- * keys a source (`path` + `field`), so the caller can join it back to the source's
- * model without spelling a path of its own. A `mapDefaults`-declared source resolves
- * wherever its model appears, so `path` may name a relation chain the narrowing never
- * spelled under `root.relations`; the dotted format is the same.
- */
-type RuleSourceValues = {
-    path: string;
-    mapName: string;
+type PrismaWhere = Record<string, unknown>;
+type StepRef = {
+    __step: number;
+};
+type GroupByStep = {
+    operation: 'groupBy';
     model: string;
-    field: string;
-    /** Every literal a leaf at this source named; list operators flattened, deduped by content. */
-    values: RuleValue[];
-    /**
-     * The set of values cannot be enumerated from literals: a leaf took its value from
-     * `path` / `bind`, used an operator that describes values without naming them
-     * (substring, pattern, range, date window), or used an operator the catalog does not
-     * know. A caller deciding anything from `values` must fail closed.
-     */
-    dynamic: boolean;
+    args: {
+        by: string[];
+        where: Record<string, unknown>;
+        having: Record<string, unknown>;
+    };
+    extract: string;
+};
+type WhereStep = {
+    operation: 'where';
+    where: Record<string, unknown>;
+};
+type PrismaStep = GroupByStep | WhereStep;
+type ToPrismaResult = {
+    steps: PrismaStep[];
+};
+type ToPrismaOptions = CompileOptions & {
+    datasource?: {
+        provider?: PrismaProvider;
+    };
 };
-/**
- * Which values a rule names at each source the lens declares — the lens owns the
- * vocabulary, so it answers questions about it; callers never spell a path. A leaf reaches a
- * source by its absolute path through the lens: nested (`{ field: 'orders', arrayOperator,
- * condition: { field: 'sku' } }`) and dotted (`{ field: 'orders.sku' }`) spellings are one path,
- * resolved by `walkLensPath` — visibility, `mapDefaults`, and the Json boundary all apply, so a
- * source declared in `mapDefaults` answers wherever its model appears. Quantifier-blind on
- * purpose — a `none` relation names its value as much as an `any` one, `notIn` as much as `in` —
- * but shape-aware via the operator catalog: only literal-naming shapes contribute `values`;
- * substring / pattern / range / window operators, and operators the catalog does not know, mark
- * the source `dynamic` instead of inventing values. A relation node's own comparison (an
- * aggregate's threshold, an array `count`) belongs to the node, not to a source. Paths invisible
- * under the lens, unmapped segments, and sub-paths beneath a Json column are silent.
- */
-declare const ruleSourceValues: (lensOrNarrowing: Lens | LensNarrowing, rule: Condition) => RuleSourceValues[];
 
 /** Prisma `select` shape — nested for a grouped source's relation path. */
 type SourceSelect = {
@@ -901,11 +742,11 @@ type SourceSelect = {
 type SourcePrismaQuery = {
     model: string;
     /** Absent for grouped sources — DISTINCT on the value column alone would collapse
-     * same-value rows across groups; dedup happens in `sourceValuesFromQueryRows`. */
+     * same-value rows across groups; dedup happens in `materializeSourceQuery`. */
     distinct?: string[];
     select: SourceSelect;
     where: PrismaWhere;
-    /** Present only if the composed where used count operators (run via executePrismaQueryPlan). */
+    /** Present only if the composed where used count operators (run via executePrismaPlan). */
     steps?: PrismaStep[];
 };
 /** `sql` is null when the composed where uses a predicate SQL can't express
@@ -937,41 +778,103 @@ type SourceQuery = {
  * the projected lens. The WHERE is the field's composed eligibility: the model's
  * own narrowing at that path AND its source where(s). The app runs these (with
  * its own client) to materialize each field's option set — feed the fetched rows
- * to `sourceValuesFromQueryRows`.
+ * to `materializeSourceQuery`.
  */
-declare const sourceQueries: (lensOrNarrowing: Lens | LensNarrowing) => SourceQuery[];
+declare const toSourceQueries: (lensOrNarrowing: Lens | LensNarrowing) => SourceQuery[];
 
-type Row$1 = Record<string, unknown>;
 /** Which executor produced the rows — the caller always knows; never guessed. */
 type SourceRowShape = 'prisma' | 'sql';
 /**
  * Materialize one compiled `SourceQuery`'s fetched rows into its `SourceValues` —
- * the executor-side counterpart of `sourceQueries`, so apps never hand-map rows.
+ * the executor-side counterpart of `toSourceQueries`, so apps never hand-map rows.
  * `rowShape` names the wire format: prisma rows (default) nest each `groupBy` axis
  * (and a dotted `label`) as related objects; sql rows carry them flat under the
  * statement's `__group_i` / `__label` aliases. Grouped queries fetch without
  * DISTINCT, so dedup per (groups, value) happens here.
  */
-declare const sourceValuesFromQueryRows: (query: SourceQuery, rows: readonly Row$1[], opts?: {
+/** `rowShape`: how the rows came back — nested Prisma rows (the default) or flat SQL rows. */
+type MaterializeSourceQueryOptions = {
     rowShape?: SourceRowShape;
-}) => SourceValues;
+};
+declare const materializeSourceQuery: (query: SourceQuery, rows: readonly Row[], opts?: MaterializeSourceQueryOptions) => SourceValues;
 
-type Row = Record<string, unknown>;
 /**
  * Materialize each sourced field's option set from an already-fetched collection —
- * the in-memory executor of `sources` declarations, alongside `sourceQueries`
+ * the in-memory executor of `sources` declarations, alongside `toSourceQueries`
  * (which compiles the same declarations to DISTINCT queries for a DB). Rows are
- * the collection fetched UNDER the lens (relations inline), so they are already
- * lens-scoped: eligibility here is the field's source `where` only, evaluated via
- * `check()` (`options` feeds `{bind}` clauses). Scalar-list fields contribute one
+ * the collection fetched under the lens (relations inline). Each row must meet the field's
+ * eligibility as `toSourceQueries` composes it — its source `where`, the grants above it, the
+ * guards of the relations it crosses and any allowed values — evaluated with `check()`
+ * (`options` feeds `{bind}` clauses). Scalar-list fields contribute one
  * option per element, labels take the first non-null value of the label column
  * (a sibling, or a dotted to-one path read through the nested rows), and sorting is
- * numeric-aware in a fixed locale. Feed the result to `exposedSurface` /
- * `projectByPath` as `{ sourceValues }`.
+ * numeric-aware in a fixed locale. Feed the result to `projectLens` as `{ sourceValues }`.
+ */
+declare const materializeSources: (lensOrNarrowing: Lens | LensNarrowing, rows: readonly Row[], options?: CheckOptions) => SourceValues[];
+
+declare const validateNarrowing: (narrowing: LensNarrowing) => ValidationResult;
+declare const assertValidNarrowing: (narrowing: LensNarrowing) => void;
+
+declare const narrowRule: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => Condition;
+
+/**
+ * What a narrowed lens exposes. `by: 'path'` (the default) projects each declared path — its
+ * visible fields, `where` clauses and sources — keyed by dotted path. `by: 'model'` flattens the
+ * whole surface into a Lens: every model a path or relation reaches, each field the union of its
+ * visits, bridges kept only where an exposed field crosses them.
+ */
+declare function projectLens(lensOrNarrowing: Lens | LensNarrowing, options?: ProjectLensOptions & {
+    by?: 'path';
+}): PathProjection;
+declare function projectLens(lensOrNarrowing: Lens | LensNarrowing, options: ProjectLensOptions & {
+    by: 'model';
+}): Lens;
+
+/**
+ * A lens as stored, one record per layer: its `id`, the ids of every layer it composes with —
+ * the base lens first, the nearest parent last — and its own part. The base lens is the
+ * root-most layer: the lens itself, with no parents.
+ */
+type StoredLens = {
+    id: string;
+    parents: string[];
+} & (Lens | Omit<LensNarrowing, 'parent'>);
+/**
+ * The composed lens a stored layer resolves to: its parents, read from `records`, nested from
+ * the base down, each layer validated against the ones above it. Fails closed on a missing
+ * record, a base that isn't first, or a parent whose own parents disagree with the list.
+ */
+declare const composeLens: (id: string, records: Record<string, StoredLens>) => Lens | LensNarrowing;
+/** A composed lens as the records `composeLens` reads back: one per layer, the base first,
+ *  named by `ids` in the same order. */
+declare const storeLens: (lens: Lens | LensNarrowing, ids: readonly string[]) => StoredLens[];
+
+/** Gate a rule against a lens: every field and value-side ref resolves through it, and every
+ *  operator, value and amount fits the field it reaches. */
+declare const validateRuleInLens: (rule: Condition, lensOrNarrowing: Lens | LensNarrowing) => ValidationResult;
+
+/**
+ * Resolve one dotted path through a lens, hop by hop, verifying as it walks: every hop is checked
+ * against the narrowing at that visit, so a relation the narrowing dropped is `hidden`, a column the
+ * model lacks is `missing`, and a segment past a scalar is `pastScalar`. This is the walk
+ * `validateRuleInLens` gates a rule's field with, exposed for consumers that resolve paths of their
+ * own (template tokens, loop bindings, presence guards).
  */
-declare const sourceValuesFromRows: (lensOrNarrowing: Lens | LensNarrowing, rows: readonly Row[], options?: CheckOptions) => SourceValues[];
+declare const walkLensPath: (lensOrNarrowing: Lens | LensNarrowing, path: string) => LensPathResolution;
 
-declare const stampCoercions: (condition: Condition, lensOrNarrowing: Lens | LensNarrowing) => Condition;
+type ScopeRef = {
+    depth: number;
+    path: string;
+};
+declare const parseScopeRef: (ref: string) => ScopeRef | null;
+type ScopedRef<S> = {
+    scope: S;
+    path: string;
+};
+type ScopeOutOfBounds = {
+    outOfBounds: string;
+};
+declare const readScopeRef: <S>(ref: string, scopes: readonly S[]) => ScopedRef<S> | ScopeOutOfBounds;
 
 /**
  * Execute a Prisma query plan produced by toPrisma().
@@ -987,75 +890,39 @@ declare const stampCoercions: (condition: Condition, lensOrNarrowing: Lens | Len
  *
  * @example
  * const plan = toPrisma(condition, { map, model: 'User' });
- * const where = await executePrismaQueryPlan(plan, { post: prisma.post });
+ * const where = await executePrismaPlan(plan, { post: prisma.post });
  * await prisma.user.findMany({ where });
  */
-declare const executePrismaQueryPlan: (result: ToPrismaResult, prismaDelegate: Record<string, Record<string, (...args: unknown[]) => unknown>>) => Promise<Record<string, unknown>>;
+declare const executePrismaPlan: (plan: ToPrismaResult, prismaDelegate: Record<string, Record<string, (...args: unknown[]) => unknown>>) => Promise<Record<string, unknown>>;
 
 /**
- * Convert a json-rules Condition to a Prisma query plan.
- *
- * Returns a `ToPrismaResult` with:
- * - `where` – the Prisma WHERE clause
- * - `steps` – optional array of groupBy steps for count-based relation filters
- *   (only present when `atLeast`/`atMost`/`exactly` operators are used with a map)
- *
- * When `steps` is present, pass the result to `executePrismaQueryPlan` to
- * resolve step refs before using `where` in a Prisma query.
- *
- * @param condition - The rule condition to convert
- * @param options   - Optional map, model, and context
+ * Compile a condition to a Prisma query plan: `steps`, any groupBy steps (counts and relation
+ * aggregates, which need `{ map, model }`) and then the final `where`. Run a plan with
+ * `executePrismaPlan(plan, client)` to resolve step refs; a single-step plan's `where` is its
+ * last step's.
  *
  * @example
  * ```typescript
- * // Simple scalar
- * toPrisma({ field: 'status', operator: Operator.equals, value: 'active' })
- * // → { where: { status: { equals: 'active' } } }
- *
- * // JSON field detection (map required)
- * toPrisma({ field: 'metadata.theme', operator: Operator.equals, value: 'dark' }, { map, model: 'User' })
- * // → { where: { metadata: { path: ['theme'], equals: 'dark' } } }
+ * toPrisma({ field: 'status', operator: Operator.equals, value: 'active' }).steps
+ * // → [{ operation: 'where', where: { status: { equals: 'active' } } }]
  *
- * // Context path ref
- * toPrisma({ field: 'userId', operator: Operator.equals, path: 'currentUser.id' }, { context: { currentUser: { id: '123' } } })
- * // → { where: { userId: { equals: '123' } } }
- *
- * // Multi-step (map required)
- * const plan = toPrisma({ field: 'posts', arrayOperator: 'atLeast', count: 3, condition: {...} }, { map, model: 'User' });
- * const where = await executePrismaQueryPlan(plan, { post: prisma.post });
+ * const plan = toPrisma({ field: 'posts', arrayOperator: 'atLeast', count: 3, condition }, { map, model: 'User' });
+ * const where = await executePrismaPlan(plan, prisma);
  * await prisma.user.findMany({ where });
  * ```
  */
-declare const toPrisma: (condition: Condition, options?: BuildOptions) => ToPrismaResult;
+declare const toPrisma: (condition: Condition, options?: ToPrismaOptions) => ToPrismaResult;
 
-type SqlResult = {
+type ToSqlResult = {
     sql: string;
     params: unknown[];
     joins: string[];
 };
-
-type SqlBuildOptions = {
-    map?: FieldMap;
-    model?: string;
+type ToSqlOptions = CompileOptions & {
+    /** The root table alias; `t0` when a map is given. */
     alias?: string;
-    context?: Record<string, unknown>;
-} & DateConfig;
-declare const toSql: (condition: Condition, options?: SqlBuildOptions) => SqlResult;
-
-type ValidationIssue = {
-    path: string;
-    message: string;
-    code: string;
 };
-type ValidationResult = {
-    ok: boolean;
-    errors: ValidationIssue[];
-};
-declare const validateRule: (condition: unknown, options?: {
-    target?: RuleTarget;
-}) => ValidationResult;
-declare const assertValidRule: (condition: unknown, options?: {
-    target?: RuleTarget;
-}) => asserts condition is Condition;
 
-export { AGGREGATE_OPERATORS, ALL_KINDS, ARRAY_OPERATOR_CATALOG, type AggregateMode, type AggregateRule, type All, type Any, type ArrayCatalogEntry, ArrayOperator, type ArrayRule, type Bridge, type BridgeCardinality, type BridgeDictionary, type BridgeEndpoint, type BuildOptions, COERCIBLE_KINDS, COMPILE_COERCED_KINDS, type CatalogEntry, type CheckOptions, type Condition, type CreateLensInput, DATE_OPERATOR_CATALOG, type DateConfig, type DateExpr, type DateInputOrExpr, type DateInputValue, type DateOffset, DateOperator, type DateRule, type DateRuleValue, EQUATABLE_KINDS, type EdgeExpr, type EngineGlobalsState, type EnumNarrowing, FIELD_OPERATOR_CATALOG, FieldKind, type FieldMap, type FieldMapEntry, type FieldMapSet, type FuzzyConfig, type GroupByStep, INTEGER_KINDS, INTERVAL_FIELDS, type IfThenElse, LOWER_BOUND_OPERATORS, type Lens, type LensNarrowing, type LensPathHop, type LensPathResolution, type Magnitude, type ModelDefaultNarrowing, type ModelNarrowing, NEGATED_COMPARISON_OPERATORS, NEGATED_OPERATORS, NEGATED_RANGE_OPERATORS, NEGATED_SINGLE_VALUE_OPERATORS, NO_VALUE_OPERATORS, NULLABLE_KINDS, NUMERIC_KINDS, type NarrowingDefaults, type NumberOffset, OFFSET_OPERATORS, ORDERABLE_KINDS, ORDERED_OPERATORS, Operator, type OrderBy, type OrderedRuleValue, PERIOD_UNITS, type PathProjection, type PeriodExpr, type PeriodUnit, type PrismaProvider, type PrismaStep, type PrismaWhere, type ProjectOptions, type ProjectedVisit, RANGE_OPERATORS, RELATIVE_UNITS, type RelativeUnit, type RelativeUnits, type RollingExpr, type Rule, type RuleDescription, type RuleLensCheck, type RuleLensViolation, type RuleScalar, type RuleSourceValues, RuleTarget, type RuleValue, SINGLE_VALUE_SHAPES, STRINGY_KINDS, type ScopeOutOfBounds, type ScopeRef, type ScopedRef, type SortDir, type SourceOption, type SourcePrismaQuery, type SourceQuery, type SourceRowShape, type SourceSpec, type SourceSqlQuery, type SourceValue, type SourceValues, type SqlResult, type StepRef, type StrictAggregateRule, type StrictAll, type StrictAny, type StrictArrayCountRule, type StrictArrayPredicateRule, type StrictArrayPresenceRule, type StrictArrayRule, type StrictCondition, type StrictContainsRule, type StrictDateComparisonRule, type StrictDateDayRule, type StrictDateRangeRule, type StrictDateRule, type StrictEqualityRule, type StrictIfThenElse, type StrictMembershipRule, type StrictOrderedComparisonRule, type StrictPatternRule, type StrictPresenceRule, type StrictRangeRule, type StrictRule, type StrictStringBoundaryRule, type TimeZoneConfig, type ToPrismaResult, UPPER_BOUND_OPERATORS, type ValidationIssue, type ValidationResult, ValueShape, type ValueSourceFields, type ValueSourceOf, WINDOW_OPERATORS, WINDOW_SELECTOR, type WeekStart, type WhereStep, type WindowFields, type WindowRuleType, WindowSupport, applyLens, assertValidRule, bindingNames, buildBridgeDictionary, check, checkRuleAgainstLens, createLens, describeRule, engineGlobals, executePrismaQueryPlan, exposedSurface, fuzzyContains, getAggregateOperators, getArrayOperators, getOperatorsForKind, getValueShape, getWindowSupport, isAggregateRangeOperator, isAggregateSingleOperator, isCalendarUnit, isOperatorSupportedForTarget, isRelativeUnit, lensRequiredBindings, maxFuzzyDistance, parseScopeRef, projectByPath, readBinding, requiredBindings, resolveBindings, resolveCaseInsensitive, resolveFuzzy, resolveLensBindings, resolveLensPath, resolveScopeRef, ruleSourceValues, sourceQueries, sourceValuesFromQueryRows, sourceValuesFromRows, stampCoercions, stitchFieldMaps, supportsQueryMode, toPrisma, toSql, validateBindNames, validateFieldMap, validateFieldMapSet, validateNarrowing, validateRule };
+declare const toSql: (condition: Condition, options?: ToSqlOptions) => ToSqlResult;
+
+export { ALL_KINDS, type AggregateMode, type AggregateRule, type All, type Any, ArrayOperator, type ArrayRule, type Bridge, type BridgeCardinality, type BridgeDictionary, type BridgeEndpoint, type CheckData, type CheckOptions, type CompileOptions, type Condition, type DateConfig, type DateExpr, type DateInputOrExpr, type DateInputValue, type DateOffset, DateOperator, type DateRule, type DateRuleValue, type EdgeExpr, type EngineGlobalsState, type EnumNarrowing, FieldKind, type FieldMap, type FieldMapEntry, type FieldMapSet, type FuzzyConfig, type GroupByStep, type IfThenElse, type Lens, type LensNarrowing, type LensPathHop, type LensPathResolution, type ListBindingsOptions, type Magnitude, type MaterializeSourceQueryOptions, type ModelDefaultNarrowing, type ModelEntry, type ModelNarrowing, NUMERIC_KINDS, type NarrowingDefaults, type NumberOffset, Operator, type OperatorFamily, type OrderBy, type OrderedRuleValue, type PathProjection, type PeriodExpr, type PeriodUnit, type PrismaProvider, type PrismaStep, type PrismaWhere, type ProjectLensOptions, type ProjectedVisit, type RelativeUnits, type RollingExpr, type Row, type Rule, type RuleDescription, type RuleScalar, type RuleSourceDescription, RuleTarget, type RuleValue, type ScopeOutOfBounds, type ScopeRef, type ScopedRef, type SortDir, type SourceEntry, type SourceOption, type SourcePrismaQuery, type SourceQuery, type SourceRowShape, type SourceSelect, type SourceSpec, type SourceSqlQuery, type SourceValues, type StepRef, type StoredLens, type StrictAggregateRule, type StrictAll, type StrictAny, type StrictArrayCountRule, type StrictArrayPredicateRule, type StrictArrayPresenceRule, type StrictArrayRule, type StrictCondition, type StrictContainsRule, type StrictDateComparisonRule, type StrictDateDayRule, type StrictDateRangeRule, type StrictDateRule, type StrictEqualityRule, type StrictIfThenElse, type StrictMembershipRule, type StrictOrderedComparisonRule, type StrictPatternRule, type StrictPresenceRule, type StrictRangeRule, type StrictRule, type StrictStringBoundaryRule, type TimeZoneConfig, type ToPrismaOptions, type ToPrismaResult, type ToSqlOptions, type ToSqlResult, type ValidateRuleOptions, type ValidationIssue, type ValidationResult, ValueShape, type ValueSourceFields, type ValueSourceOf, type WeekStart, type WhereStep, type WindowFields, assertValidFieldMaps, assertValidNarrowing, assertValidRule, bindLens, bindRule, check, coerceRule, composeLens, createLens, describeRule, describeRuleSources, engineGlobals, executePrismaPlan, getAggregateOperators, getArrayOperators, getOperatorsForKind, getValueShape, indexBridges, listBindings, listLensBindings, materializeSourceQuery, materializeSources, narrowRule, parseScopeRef, projectLens, readScopeRef, stitchFieldMaps, storeLens, toPrisma, toSourceQueries, toSql, validateFieldMaps, validateNarrowing, validateRule, validateRuleInLens, walkLensPath };