okmodel 0.1.1 → 0.2.1

package/dist/contracts/generator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Client generators.
+ *
+ * A generator fills a column on insert. It is not a database default, so it
+ * stays off the catalog and its hash. Built-ins are marked by name so
+ * `connect({ generators })` can replace them.
+ */
+/** Property that marks a function as a client generator. */
+export declare const CLIENT_DEFAULT: unique symbol;
+/** Built-in generator names, plus a caller-supplied function. */
+export type GeneratorName = "uuidv4" | "uuidv7" | "okid" | "function";
+/** Scalar options stored with a named generator. OKID uses these. */
+export type GeneratorOptions = Readonly<Record<string, string | number | boolean>>;
+/**
+ * What insert calls when a column was omitted.
+ *
+ * `label` is the catalog-output word for a client default. The catalog
+ * document itself does not store it.
+ */
+export type ClientFill = {
+    readonly label: "client";
+    readonly name: GeneratorName;
+    readonly options?: GeneratorOptions;
+    readonly call: () => unknown;
+};
+/** A function `.default()` and `schema({ defaults: { id } })` accept. */
+export type ClientGenerator<T = string> = (() => T) & {
+    readonly [CLIENT_DEFAULT]: {
+        readonly label: "client";
+        readonly name: Exclude<GeneratorName, "function">;
+        readonly options?: GeneratorOptions;
+    };
+};
+/**
+ * Replacements for the built-in generators, keyed by name.
+ *
+ * A test passes fixed functions here. A custom function with no name is left
+ * alone.
+ */
+export type IdGenerators = {
+    readonly uuidv4?: () => string;
+    readonly uuidv7?: () => string;
+    readonly okid?: () => string;
+};
+/**
+ * Marks `call` as a named client generator.
+ *
+ * @typeParam T - Value the generator returns
+ * @param call - Function that produces one value
+ * @param name - Built-in name `connect({ generators })` can replace
+ * @param options - Scalar options stored beside the name
+ * @returns The same function, marked
+ */
+export declare function clientGenerator<T>(call: () => T, name: Exclude<GeneratorName, "function">, options?: GeneratorOptions): ClientGenerator<T>;
+/**
+ * Reads a client generator from a `.default()` argument.
+ *
+ * A marked built-in keeps its name. Any other function is a custom generator.
+ *
+ * @param value - Argument passed to `.default()` or `defaults.id`
+ * @returns The fill insert should call, or `undefined` when `value` is a literal
+ */
+export declare function readClientGenerator(value: unknown): ClientFill | undefined;

package/dist/contracts/index.d.ts

@@ -6,6 +6,6 @@
  * live on `okmodel/internal`, so `table` and `index` on this entry are not a
  * second schema API.
  */
-export { CATALOG_CODES, COLUMN_CODES, ERROR_CATEGORIES, ERROR_KINDS, OkmError, safe, type CatalogCode, type ColumnCode, type QueryCode, type ErrorCategory, type ErrorColumns, type ErrorFields, type ErrorFix, type ErrorKind, type ErrorLog, type ErrorStatuses, type HttpError, type HttpErrorBody, type OkmErrorOptions, type SafeResult, } from "./error.js";
-export type { AnySchema, AnyTableShape, Insert, Register, Row, SchemaOf, TableName, Update, } from "./rows.js";
+export { CATALOG_CODES, COLUMN_CODES, ERROR_CATEGORIES, ERROR_KINDS, OkmError, safe, type CatalogCode, type ColumnCode, type QueryCode, type ErrorCategory, type ErrorColumns, type ErrorFields, type ErrorFix, type ErrorKind, type ErrorLog, type ErrorStatuses, type HttpError, type HttpErrorBody, type OkmErrorOptions, type SafeResult, type ValidationIssue, } from "./error.js";
+export type { AnySchema, AnyTableShape, Input, Insert, Register, Row, SchemaOf, TableName, Update, } from "./rows.js";
 export type { DescribeResult, DriverCapabilities, DriverConnection, DriverErrorFields, DriverFailureKind, DriverPool, DriverPoolConfig, DriverStats, ExecuteOptions, ExecuteResult, Notice, PreparedMode, Statement, TransactionMode, WireValue, } from "./driver.js";

package/dist/contracts/index.js

@@ -5,7 +5,7 @@ import {
   ERROR_CATEGORIES2,
   OkmError2,
   safe2
-} from "../shared/ycwz42az.js";
+} from "../shared/52szzakm.js";
 export {
   CATALOG_CODES2 as CATALOG_CODES,
   COLUMN_CODES2 as COLUMN_CODES,

package/dist/contracts/internal.js

@@ -1,10 +1,4 @@
 import {
-  OWNERS2,
-  OBJECT_KINDS2,
-  BUILT_KINDS2,
-  OBJECT_OPERATIONS2,
-  KIND_OPERATIONS2,
-  CATALOG_VERSION2,
   staticNamespace2,
   templateNamespace2,
   assertNamespace2,
@@ -19,7 +13,15 @@ import {
   index3,
   constraint2,
   sequence2
-} from "../shared/j5cn2963.js";
+} from "../shared/t4tbsy9h.js";
+import {
+  OWNERS2,
+  OBJECT_KINDS2,
+  BUILT_KINDS2,
+  OBJECT_OPERATIONS2,
+  KIND_OPERATIONS2,
+  CATALOG_VERSION2
+} from "../shared/4e4c6vq2.js";
 import {
   utf8ByteLength2,
   sha2562,
@@ -28,12 +30,12 @@ import {
   assertIdentifier2,
   fitIdentifier2,
   deterministicName2
-} from "../shared/mkjmqjv4.js";
+} from "../shared/nfzc5z0w.js";
 import {
   nearestName2,
   catalogError2,
   throwNamed2
-} from "../shared/ycwz42az.js";
+} from "../shared/52szzakm.js";
 export {
   BUILT_KINDS2 as BUILT_KINDS,
   CATALOG_VERSION2 as CATALOG_VERSION,

package/dist/contracts/location.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Authoring location for provenance.
+ *
+ * `source` is recorded when a table or a rule is defined. The catalog hash
+ * does not include it.
+ */
+/**
+ * File and line of the caller `skip` frames above this function.
+ *
+ * Frames in this file are ignored. `skip` 1 is the direct caller, so a
+ * `table()` call records the schema line, not `table` itself.
+ *
+ * @param skip - Callers to pass before the frame that is recorded
+ * @returns `file.ts:line`, or `undefined` when the runtime has no stack
+ */
+export declare function callerLocation(skip: number): string | undefined;
+/**
+ * Appends a source location to an error message.
+ *
+ * @param message - What failed
+ * @param source - `file.ts:line`, when one was recorded
+ * @returns The message `okm` prints
+ */
+export declare function withLocation(message: string, source: string | undefined): string;

package/dist/contracts/rows.d.ts

@@ -70,6 +70,21 @@ export type Insert<N extends TableName<S>, S extends AnySchema | undefined = und
  * @typeParam S - Explicit schema. Omit it to use {@link Register}
  */
 export type Update<N extends TableName<S>, S extends AnySchema | undefined = undefined> = ShapeOf<S, N, "~update">;
+/**
+ * Insert shape used when validation is on.
+ *
+ * The fields match {@link Insert}. The optional mark makes the two types
+ * distinct, so a checked call can require this shape only while validation
+ * is enabled. Guarded fields and the tenant key are already absent.
+ *
+ * @typeParam N - Table name
+ * @typeParam S - Explicit schema. Omit it to use {@link Register}
+ */
+export type Input<N extends TableName<S>, S extends AnySchema | undefined = undefined> = Insert<N, S> & InputMark;
+/** Optional mark that distinguishes {@link Input} from {@link Insert}. */
+export type InputMark = {
+    readonly "~input"?: true;
+};
 /**
  * One phantom on the table named `N`.
  *

package/dist/dialects/pg/archive-bind.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Cascade checks and partial uniques for `archivable()`.
+ *
+ * The trait calls this from the schema rewrite, after tenancy widens uniques.
+ * `schema()` does not import it.
+ */
+import { type AnyTable } from "./table.js";
+/**
+ * Makes an archivable table's uniques partial and checks its cascade.
+ *
+ * Tenancy has already widened uniques. This pass turns those lists into
+ * unique indexes filtered on `archived_at is null`, and stores the cascade
+ * links the planner reads.
+ *
+ * @param self - The trait object on the table or the schema
+ * @param tables - Tables after the tenancy rewrite
+ * @param casing - Schema casing
+ * @param schemaTraits - Traits from `schema()`, when any were passed
+ * @param cascade - Child tables named on this trait
+ * @returns Tables with partial uniques and an archive model where this trait applies
+ */
+export declare function rewriteArchivable(self: object, tables: readonly AnyTable[], casing: "snake" | undefined, schemaTraits: readonly object[] | undefined, cascade: readonly string[]): readonly AnyTable[];

package/dist/dialects/pg/column.d.ts

@@ -2,9 +2,10 @@
  * Column builder shared by every Postgres type.
  *
  * Modifiers allocate a new builder when called. Importing this module does
- * not build a codec table. `.validate()` stays a slot for P26.
+ * not build a codec table. `.validate()` stores rules and does not run them.
  */
 import { type ReferentialAction } from "../../contracts/catalog/types.js";
+import { type ClientFill } from "../../contracts/generator.js";
 /** Flags that decide the row, insert, and update shapes of one column. */
 export type ColumnFlags = {
     readonly nullable: boolean;
@@ -13,6 +14,8 @@ export type ColumnFlags = {
     readonly guarded: boolean;
     readonly hidden: boolean;
     readonly omitWrite: boolean;
+    /** Absent from update. Insert still follows {@link InsertKind}. */
+    readonly omitUpdate: boolean;
 };
 /** Flags for a required column with no default. */
 export type PlainFlags = {
@@ -22,8 +25,9 @@ export type PlainFlags = {
     readonly guarded: false;
     readonly hidden: false;
     readonly omitWrite: false;
+    readonly omitUpdate: false;
 };
-/** Flags for {@link id}. Insert and update omit it. */
+/** Flags for {@link id} when the database fills the value. Insert and update omit it. */
 export type IdFlags = {
     readonly nullable: false;
     readonly hasDefault: true;
@@ -31,6 +35,21 @@ export type IdFlags = {
     readonly guarded: true;
     readonly hidden: false;
     readonly omitWrite: true;
+    readonly omitUpdate: true;
+};
+/**
+ * Flags for {@link id} with `default: "none"`.
+ *
+ * Insert requires the value. Update omits it.
+ */
+export type IdSuppliedFlags = {
+    readonly nullable: false;
+    readonly hasDefault: false;
+    readonly generated: false;
+    readonly guarded: false;
+    readonly hidden: false;
+    readonly omitWrite: false;
+    readonly omitUpdate: true;
 };
 /** Flags for {@link identity}. The database fills the value. */
 export type IdentityFlags = {
@@ -40,6 +59,7 @@ export type IdentityFlags = {
     readonly guarded: false;
     readonly hidden: false;
     readonly omitWrite: true;
+    readonly omitUpdate: true;
 };
 /**
  * Turns one flag on.
@@ -58,6 +78,14 @@ export type FlagTrue<TFlags extends ColumnFlags, K extends keyof ColumnFlags> =
 export type WithGenerated<TFlags extends ColumnFlags> = {
     readonly [P in keyof TFlags]: P extends "generated" | "hasDefault" ? true : TFlags[P];
 };
+/**
+ * Omits a column from update and leaves insert unchanged.
+ *
+ * @typeParam TFlags - Current flags
+ */
+export type WithUpdateGuard<TFlags extends ColumnFlags> = {
+    readonly [P in keyof TFlags]: P extends "omitUpdate" ? true : TFlags[P];
+};
 /** How a default expression is spelled in the catalog. */
 export type SqlForm = "raw" | "quote" | "json" | "jsonb" | "cast";
 /**
@@ -70,7 +98,14 @@ export type ReferenceModifier = {
     readonly table: string;
     readonly onDelete?: ReferentialAction;
     readonly onUpdate?: ReferentialAction;
+    /** Target columns. Several columns make a composite foreign key. */
     readonly columns?: readonly string[];
+    /**
+     * Other local columns in the foreign key, after this column.
+     *
+     * Set when the key is composite. Absent on a single-column reference.
+     */
+    readonly along?: readonly string[];
 };
 /**
  * Options for {@link ColumnBuilder.references}.
@@ -81,7 +116,7 @@ export type ReferenceOptions = {
     readonly columns?: readonly string[];
 };
 /**
- * Validation rules, stored when a later prompt adds `.validate()`.
+ * Validation rules stored on the column. Nothing here interprets them.
  */
 export type ValidateModifier = {
     readonly rules: readonly unknown[];
@@ -114,7 +149,7 @@ export type ColumnInsert<TFlags extends ColumnFlags, TValue> = InsertKind<TFlags
  * @typeParam TFlags - Column flags
  * @typeParam TValue - Scalar or array value
  */
-export type ColumnUpdate<TFlags extends ColumnFlags, TValue> = InsertKind<TFlags> extends "omit" ? never : TFlags["nullable"] extends true ? TValue | null | undefined : TValue | undefined;
+export type ColumnUpdate<TFlags extends ColumnFlags, TValue> = TFlags["omitUpdate"] extends true ? never : InsertKind<TFlags> extends "omit" ? never : TFlags["nullable"] extends true ? TValue | null | undefined : TValue | undefined;
 /**
  * Row shape of a builder.
  *
@@ -141,6 +176,20 @@ export type ColumnState<TValue> = {
     readonly hasDefault: boolean;
     readonly defaultSql: string | undefined;
     readonly defaultValue: unknown;
+    /**
+     * Client generator. Absent from the catalog and its hash.
+     *
+     * The catalog output labels it `client`. Insert fills the column when the
+     * caller omits it.
+     */
+    readonly clientDefault: ClientFill | undefined;
+    /** Column collation. Omitted from the catalog when unset. */
+    readonly collation: string | undefined;
+    /**
+     * `implicit` is a bare `t.id()`. `schema({ defaults: { id } })` may replace
+     * it. `column` is a choice on that column and wins.
+     */
+    readonly idSource: "implicit" | "column" | undefined;
     readonly identity: {
         readonly always: boolean;
     } | undefined;
@@ -158,7 +207,10 @@ export type ColumnState<TValue> = {
     } | undefined;
     readonly guarded: boolean;
     readonly hidden: boolean;
+    /** Redacted in logs, errors, and `inspect()`. Not part of the catalog hash. */
+    readonly sensitive: boolean;
     readonly omitWrite: boolean;
+    readonly omitUpdate: boolean;
     readonly renamedFrom: string | undefined;
     readonly sqlName: string | undefined;
     readonly comment: string | undefined;
@@ -179,6 +231,11 @@ export type ColumnState<TValue> = {
     readonly decode: (wire: string) => TValue;
     readonly elementEncode: (value: unknown) => string;
     readonly elementDecode: (wire: string) => unknown;
+    /**
+     * Object kinds the codec takes as input, named by `Object.prototype.toString`
+     * (`"Array"`, `"Temporal.Instant"`). Absent when the codec takes only scalars.
+     */
+    readonly accepts: readonly string[] | undefined;
 };
 /** Fields a scalar builder sets. Flags are passed beside the codec. */
 export type OpenColumn<TValue> = {
@@ -189,10 +246,15 @@ export type OpenColumn<TValue> = {
     readonly guarded: boolean;
     readonly hidden: boolean;
     readonly omitWrite: boolean;
+    readonly omitUpdate?: boolean;
     readonly encode: (value: TValue) => string;
     readonly decode: (wire: string) => TValue;
+    readonly accepts?: readonly string[];
     readonly sqlForm: SqlForm;
     readonly defaultSql?: string;
+    readonly clientDefault?: ClientFill;
+    readonly collation?: string;
+    readonly idSource?: "implicit" | "column";
     readonly identity?: {
         readonly always: boolean;
     };
@@ -248,12 +310,16 @@ export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
      */
     nullable(): ColumnBuilder<TValue, FlagTrue<TFlags, "nullable">>;
     /**
-     * Stores a JavaScript default. The catalog receives its SQL spelling.
+     * Stores a literal database default, or a client generator.
+     *
+     * A literal is written into the catalog as SQL. A function is a client
+     * generator: insert fills the column when it is omitted, and the catalog
+     * stores no default. Pass `uuidv4`, `uuidv7`, `okid(...)`, or any function.
      *
-     * @param value - Default value
+     * @param value - Literal default, or a function that returns one value
      * @returns The same column, with a default
      */
-    default(value: TFlags["nullable"] extends true ? TValue | null : TValue): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
+    default(value: (TFlags["nullable"] extends true ? TValue | null : TValue) | (() => TValue)): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
     /**
      * Stores a SQL default expression as written.
      *
@@ -262,14 +328,26 @@ export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
      */
     defaultSql(expression: string): ColumnBuilder<TValue, FlagTrue<TFlags, "hasDefault">>;
     /**
-     * Records a unique constraint. Tenancy later reads `global`.
+     * Makes this column the table's primary key.
+     *
+     * Insert still accepts the value. Update omits it. A composite key is the
+     * `primaryKey` option on `table()`, not a second call.
+     *
+     * @returns The same column, as a primary key
+     */
+    primaryKey(): ColumnBuilder<TValue, WithUpdateGuard<TFlags>>;
+    /**
+     * Records a unique constraint.
+     *
+     * On a tenant table the key is included, unless `global` names a reason.
+     * `global: "reason"` and `{ global: true, reason }` are the same opt-out.
      *
      * @param options - Exemption reason, and whether the unique ignores the tenant key
      * @returns The same column
      */
     unique(options?: {
         readonly reason?: string;
-        readonly global?: boolean;
+        readonly global?: boolean | string;
     }): ColumnBuilder<TValue, TFlags>;
     /**
      * Narrows a string column to a literal union.
@@ -303,9 +381,33 @@ export declare class ColumnBuilder<TValue, TFlags extends ColumnFlags> {
     /**
      * Excludes the column from the default row.
      *
+     * A named `select` still returns it. Includes never do.
+     *
      * @returns The same column, hidden
      */
     hidden(): ColumnBuilder<TValue, FlagTrue<TFlags, "hidden">>;
+    /**
+     * Redacts the value in logs, errors, and `inspect()`.
+     *
+     * The stored value is unchanged. A read that selects the column still
+     * returns it. The catalog hash does not include this flag.
+     *
+     * @returns The same column, sensitive
+     */
+    sensitive(): ColumnBuilder<TValue, TFlags>;
+    /**
+     * Stores validation rules or one Standard Schema.
+     *
+     * The rules are stored. They run only when validation is enabled and the
+     * engine has loaded. A field listed here and in the table `validate`
+     * section is OKM1030, reported by `okm check`.
+     *
+     * @param rules - Rule list, or one Standard Schema
+     * @returns The same column, with the rules stored
+     */
+    validate(rules: readonly unknown[] | {
+        readonly "~standard": unknown;
+    }): ColumnBuilder<TValue, TFlags>;
     /**
      * Points this column at another table.
      *
@@ -384,3 +486,18 @@ export declare function formatType(baseType: string, dims: number): string;
  * @returns A default expression
  */
 export declare function sqlOf<TValue>(state: ColumnState<TValue>, value: TValue): string;
+/**
+ * Returns a column with a cleared unique flag or a replaced reference.
+ *
+ * `okmodel/tenancy` uses this while rewriting tables. `schema()` then compiles
+ * the result with the ordinary unique and foreign-key paths.
+ *
+ * @param column - Column to copy
+ * @param patch - Unique or primary flag to drop, or the reference to store
+ * @returns A new column builder
+ */
+export declare function retarget<TValue, TFlags extends ColumnFlags>(column: ColumnBuilder<TValue, TFlags>, patch: {
+    readonly dropUnique?: boolean;
+    readonly dropPrimary?: boolean;
+    readonly references?: ReferenceModifier;
+}): ColumnBuilder<TValue, TFlags>;

package/dist/dialects/pg/compile.d.ts

@@ -12,6 +12,7 @@ export type CompilableColumn = {
         readonly dims: number;
         readonly nullable: boolean;
         readonly defaultSql: string | undefined;
+        readonly collation: string | undefined;
         readonly identity: {
             readonly always: boolean;
         } | undefined;

package/dist/dialects/pg/custom.d.ts

@@ -16,6 +16,12 @@ export declare function custom<TValue>(spec: {
     readonly sqlType: string;
     readonly encode: (value: TValue) => string;
     readonly decode: (wire: string) => TValue;
+    /**
+     * Object kinds the codec takes, as `Object.prototype.toString` names them: `"Object"`
+     * for a plain object, `"Array"`, `"Temporal.Instant"`. Omit it when `TValue` is a
+     * scalar: every object is then rejected (OKM1121).
+     */
+    readonly accepts?: readonly string[];
     readonly extension?: string;
     readonly sqlForm?: SqlForm;
 }): ColumnBuilder<TValue, PlainFlags>;

package/dist/dialects/pg/filter-parse.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Turns an allowlisted request object into `where` and `orderBy`.
+ *
+ * Loaded the first time `parse()` is called. `filters()` validates the spec
+ * before this module exists.
+ */
+import type { ParsedFilters } from "./table.js";
+/**
+ * Reads one request object.
+ *
+ * A plain value is equality when `eq` is allowlisted. `sort` is a field name
+ * from the sort list. JSON cannot add an operator.
+ *
+ * @param allow - Fields and the operators each one accepts
+ * @param sort - Fields a caller may sort by
+ * @param query - One request object
+ * @returns Filters a caller can spread into `find`
+ */
+export declare function parseQuery(allow: Readonly<Record<string, readonly string[]>>, sort: readonly string[], query: unknown): ParsedFilters;

package/dist/dialects/pg/filters.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Allowlisted filters. The checks run when `filters()` is called.
+ *
+ * A hidden field in `allow`, `sort`, or `relations` is OKM1123. The parser
+ * loads on the first `parse()`.
+ */
+import type { FilterSpec, ParsedFilters } from "./table.js";
+/**
+ * Checks an allowlist and returns `parse`.
+ *
+ * @param table - Table the filters belong to
+ * @param relations - Relation calls stored on the table, when it has any
+ * @param spec - Allow, sort, and relation fields
+ * @param hiddenFields - `table.field` keys recorded while tables were defined
+ * @returns A parser for one request object
+ */
+export declare function openFilters(table: string, relations: unknown, spec: FilterSpec, hiddenFields: ReadonlySet<string>): {
+    parse(query: unknown): Promise<ParsedFilters>;
+};

package/dist/dialects/pg/index.d.ts

@@ -6,13 +6,14 @@
  */
 export { schema, type BuiltSchema, type SchemaCodecs, type SchemaInput, type SchemaRequires, } from "./schema.js";
 export { index, sql, table, type AnyTable, type ColumnHandle, type IndexCall, type SqlText, type SqlValue, type Table, type TableOptions, } from "./table.js";
+export type { PresetQuery } from "./preset.js";
 export { custom } from "./custom.js";
 export { ColumnBuilder } from "./column.js";
 export type { ArrayOf, ColumnFlags, ColumnInsert, ColumnInsertOf, ColumnRow, ColumnRowOf, ColumnUpdate, ColumnUpdateOf, FlagTrue, IdFlags, IdentityFlags, PlainFlags, ReferenceModifier, ReferenceOptions, SqlForm, ValidateModifier, WithGenerated, } from "./column.js";
 export { bigint, identity, integer, smallint, type BigintAs, type BigintValue } from "./integer.js";
 export { double, numeric, real, type NumericAs, type NumericValue } from "./decimal.js";
 export { boolean, bytea } from "./bool.js";
-export { json, jsonb, jsonReplacer } from "./json.js";
+export { jsonb, jsonReplacer } from "./json.js";
 export { id, uuid } from "./keys.js";
 export { char, citext, text, varchar } from "./text.js";
 export { date, interval, time, timestamp, timestamptz, timetz } from "./time.js";
@@ -23,7 +24,10 @@ export { line, point, type Line, type Point } from "./geometry.js";
 export { ltree, tsvector } from "./search.js";
 export { domain, enumColumn as enum } from "./enum.js";
 export { t } from "./namespace.js";
+export * as arr from "./ops/arr-ns.js";
+export * as json from "./ops/json-ns.js";
 export { between } from "./ops/between.js";
+export { containedBy } from "./ops/containedBy.js";
 export { contains } from "./ops/contains.js";
 export { endsWith } from "./ops/endsWith.js";
 export { eq } from "./ops/eq.js";
@@ -32,14 +36,19 @@ export { gt } from "./ops/gt.js";
 export { inc } from "./ops/inc.js";
 export { gte } from "./ops/gte.js";
 export { has } from "./ops/has.js";
+export { hasAnyKey } from "./ops/hasAnyKey.js";
+export { hasKey } from "./ops/hasKey.js";
 export { ilike } from "./ops/ilike.js";
 export { inList } from "./ops/inList.js";
 export { like } from "./ops/like.js";
+export { matches } from "./ops/matches.js";
 export { lt } from "./ops/lt.js";
 export { lte } from "./ops/lte.js";
 export { none } from "./ops/none.js";
 export { not } from "./ops/not.js";
 export { notIn } from "./ops/notIn.js";
 export { or } from "./ops/or.js";
+export { overlaps } from "./ops/overlaps.js";
+export { path } from "./ops/path.js";
 export { startsWith } from "./ops/startsWith.js";
-export { many, one, type ManyRelation, type OneRelation, type RelationCall } from "./relations.js";
+export { many, manyThrough, one, type ManyRelation, type ManyThroughRelation, type OneRelation, type RelationCall, } from "./relations.js";