okmodel 0.1.1 → 0.2.1

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

@@ -1,15 +1,31 @@
 /**
  * UUID keys.
  */
-import { type ColumnBuilder, type IdFlags, type PlainFlags } from "./column.js";
+import { type ClientGenerator } from "../../contracts/generator.js";
+import { type ColumnBuilder, type IdFlags, type IdSuppliedFlags, type PlainFlags } from "./column.js";
+/** How {@link id} fills the primary key. */
+export type IdDefault = "uuidv7" | "uuidv4" | "none";
 /**
- * UUID primary key with default `uuidv7()`.
+ * Primary key.
  *
- * Insert and update omit it, and it is guarded.
+ * With no options, the database default is `uuidv7()` unless
+ * `schema({ defaults: { id } })` says otherwise. `uuidv4` stores
+ * `gen_random_uuid()` (built in from Postgres 13). `none` takes the id on
+ * insert. A client generator (`uuidv4`, `uuidv7`, or `okid(...)` from
+ * `okmodel/ids`) is filled on insert and stored with no database default.
+ * OKID is `text` with collation `C`. A database default is omitted from
+ * insert and update. `none` is required on insert and omitted from update.
  *
+ * @param options - Which default to store. Omitted means the schema default, or `uuidv7()`
  * @returns An id column
  */
 export declare function id(): ColumnBuilder<string, IdFlags>;
+export declare function id(options: {
+    readonly default: "none";
+}): ColumnBuilder<string, IdSuppliedFlags>;
+export declare function id(options: {
+    readonly default: "uuidv7" | "uuidv4" | ClientGenerator<string>;
+}): ColumnBuilder<string, IdFlags>;
 /**
  * UUID text, with no default.
  *

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

@@ -3,6 +3,7 @@
  *
  * `schema()` fills it once. Query planning does not walk column builders again.
  */
+import type { ClientFill } from "../../contracts/generator.js";
 /** One column the planner can filter, select, decode, and write. */
 export type ColumnModel = {
     /** Field name. */
@@ -20,12 +21,42 @@ export type ColumnModel = {
      * call a codec it does not need.
      */
     readonly decode: ((wire: string) => unknown) | undefined;
-    /** Excluded from a default select. Named selects still return it. */
+    /** Excluded from a default select. Named selects still return it. Includes never return it. */
     readonly hidden: boolean;
-    /** Refused when present in insert or update input. */
+    /**
+     * Redacted in logs, errors, and `inspect()`.
+     *
+     * A selected read still returns the value.
+     */
+    readonly sensitive: boolean;
+    /** Refused when present in insert or update input, unless `{ allow }` names it. */
     readonly guarded: boolean;
     /** Included in insert and update. Guarded, generated, and omitted columns are not. */
     readonly writable: boolean;
+    /** Refused on update. Insert may still set it. A caller-supplied primary key. */
+    readonly guardUpdate: boolean;
+    /**
+     * Catalog-output label for a client default.
+     *
+     * The hashed catalog does not store it. Changing the generator does not
+     * change the catalog hash.
+     */
+    readonly clientDefault?: "client";
+    /** Called once per inserted row when the field is omitted. */
+    readonly fill?: ClientFill;
+    /**
+     * Encodes one array element.
+     *
+     * Present on array columns. `arr.append` and `arr.remove` use it.
+     */
+    readonly elementEncode?: (value: unknown) => string;
+    /**
+     * Object kinds the codec takes as input, named by `Object.prototype.toString`.
+     *
+     * Absent when the codec takes only scalars; the planner then rejects every
+     * object for the column (OKM1121).
+     */
+    readonly accepts?: readonly string[] | undefined;
 };
 /**
  * A resolved relation.
@@ -41,6 +72,89 @@ export type RelationModel = {
     readonly local: readonly string[];
     /** SQL names on the related table. */
     readonly remote: readonly string[];
+    /**
+     * Set on a `manyThrough` relation.
+     *
+     * `local` and `remote` then join the join table to this table: `remote` names
+     * columns of the join table. The pairs below join the join table to `table`.
+     */
+    readonly through?: {
+        /** Join table, by its TypeScript name. */
+        readonly table: string;
+        /** SQL names on the join table. */
+        readonly local: readonly string[];
+        /** SQL names on the related table. */
+        readonly remote: readonly string[];
+        /**
+         * Writes the join-table source and its link to the parent.
+         *
+         * The relation carries its own emitter, so a schema without `manyThrough`
+         * does not ship it. The planner passes its helpers in.
+         */
+        readonly emit: ThroughEmit;
+    };
+};
+/** Where a planner writes SQL text and statement marks. */
+export type RelationSink = {
+    text(value: string): void;
+    param(encoded: string): void;
+    mark(token: string): void;
+};
+/** A table with its columns and relations indexed by name, as the planner holds it. */
+export type PlannedTable = {
+    readonly model: TableModel;
+    readonly columns: ReadonlyMap<string, ColumnModel>;
+    readonly relations: ReadonlyMap<string, RelationModel>;
+    readonly names: readonly string[];
+};
+/** The planner helpers a relation emitter calls. */
+export type RelationPlanner = {
+    /** Writes `child.remote = parent.local` for each key column. */
+    readonly join: (sink: RelationSink, parent: string, child: string, relation: RelationModel) => void;
+    /** Writes `where` predicates, including tenancy and active-set ones, for a table. */
+    readonly where: (schema: QuerySchema, table: PlannedTable, where: unknown, sink: RelationSink, alias: string, depth: number, appended: boolean) => void;
+    /** Indexes a schema's tables by TypeScript name. */
+    readonly indexes: (schema: QuerySchema) => ReadonlyMap<string, PlannedTable>;
+    /** Quotes an identifier. */
+    readonly quote: (name: string) => string;
+};
+/**
+ * Writes `<join> <alias> join <table> ... where <link to parent>` for a
+ * `manyThrough` relation. The caller adds the related table's own predicates.
+ */
+export type ThroughEmit = (planner: RelationPlanner, schema: QuerySchema, relation: RelationModel, child: PlannedTable, sink: RelationSink, parent: string, alias: string, depth: number) => void;
+/**
+ * One foreign key the archive path follows.
+ *
+ * `local` and `remote` are SQL names, in the same order. `at` and `id` are
+ * the other table's archive columns.
+ */
+export type ArchiveLink = {
+    readonly table: string;
+    readonly sql: string;
+    readonly at: string;
+    readonly id: string;
+    readonly local: readonly string[];
+    readonly remote: readonly string[];
+};
+/**
+ * Archive columns and the children and parents resolved at schema time.
+ *
+ * Absent when the table is not archivable, so a normal table does not carry it.
+ */
+export type ArchiveModel = {
+    /** SQL name of `archivedAt`. */
+    readonly at: string;
+    /** SQL name of `archiveId`. */
+    readonly id: string;
+    /** Field name of `archivedAt`. */
+    readonly atField: string;
+    /** Field name of `archiveId`. */
+    readonly idField: string;
+    /** Children archived and restored with this row. */
+    readonly cascade: readonly ArchiveLink[];
+    /** Archivable tables this row references. Restore refuses an archived one. */
+    readonly parents: readonly ArchiveLink[];
 };
 /** One table, keyed by its TypeScript name on the schema. */
 export type TableModel = {
@@ -56,7 +170,106 @@ export type TableModel = {
     readonly uniques: readonly (readonly string[])[];
     readonly columns: readonly ColumnModel[];
     readonly relations: readonly RelationModel[];
+    /**
+     * Traits that apply to this table.
+     *
+     * Absent when it has none. Writes read `touch` and `sealed` from here.
+     */
+    readonly traits?: readonly {
+        readonly name: string;
+        readonly touch?: readonly string[];
+        readonly sealed?: readonly string[];
+    }[];
+    /**
+     * A column is hidden or sensitive.
+     *
+     * Absent when none are, so a normal table does not carry the flag.
+     */
+    readonly conceal?: true;
+    /**
+     * `file.ts:line` where the table was defined.
+     *
+     * Absent on a catalog loaded from a build artifact. Not part of the hash.
+     */
+    readonly source?: string;
+    /**
+     * Archive columns, cascade, and parent links.
+     *
+     * Absent when the table is not archivable.
+     */
+    readonly archive?: ArchiveModel;
+    /**
+     * The table's presets by name: its own and its traits', merged.
+     *
+     * Absent when it has none, so a normal table does not carry the key. The
+     * values are the author's functions; the preset module runs them.
+     */
+    readonly presets?: Readonly<Record<string, unknown>>;
+    /**
+     * Validation for this table.
+     *
+     * Absent until the engine fills it on the first validated call. `schema()`
+     * does not pack it, so a featureless table never carries it.
+     */
+    readonly validation?: ValidationModel;
 };
+/**
+ * Rules and derived checks for one table.
+ *
+ * Field rules and picklists are stored here. Column codecs stay on {@link ColumnModel}.
+ */
+export type ValidationModel = {
+    /** Run the same checks on read results. Stored for a later step. */
+    readonly onRead: boolean;
+    /** Cross-field rules from `validate.$row`, in source order. */
+    readonly row: readonly unknown[];
+    /** Per-field rules. Absent fields have none. */
+    readonly fields: Readonly<Record<string, readonly unknown[]>>;
+    /** Insert must include these fields. */
+    readonly required: readonly string[];
+    /** `null` is rejected. Includes columns that have a default. */
+    readonly notNull: readonly string[];
+    /** Picklist values, keyed by field. Absent fields have no list. */
+    readonly pick: Readonly<Record<string, readonly string[]>>;
+};
+/**
+ * One opt-in feature attaching methods to the client or a table handle.
+ *
+ * Tenancy supplies `for()` and `unscoped()`. Archivable supplies `archive()`,
+ * `restore()`, `withArchived()`, and `onlyArchived()`. Core only calls the list.
+ */
+export type SchemaHook = (target: Record<string, unknown>, ctx: SchemaHookCtx) => void;
+/**
+ * What the client passes to a {@link SchemaHook}.
+ *
+ * A client-level call sets `tables`. A table-level call sets `table`.
+ */
+export type SchemaHookCtx = {
+    readonly names?: readonly string[];
+    readonly tables?: Record<string, unknown>;
+    readonly scoped?: boolean;
+    readonly open?: (scope: {
+        readonly value: string;
+    } | {
+        readonly unscoped: string;
+    }) => unknown;
+    readonly table?: string;
+    readonly view?: "with" | "only";
+    /** The last preset chained on this handle. Absent when none is. */
+    readonly uses?: PresetUse | undefined;
+    readonly reopen?: (view?: "with" | "only") => Record<string, unknown>;
+    readonly session?: object;
+};
+/**
+ * One preset call on a table handle: the call before it, its name, and its arguments.
+ *
+ * A chain is a linked list, newest first, so adding a call allocates one tuple.
+ */
+export type PresetUse = readonly [
+    before: PresetUse | undefined,
+    name: string,
+    args: readonly unknown[]
+];
 /** Schema fields the read path and `connect()` read. */
 export type QuerySchema = {
     readonly "~byName": {
@@ -68,4 +281,12 @@ export type QuerySchema = {
     readonly requires?: {
         readonly postgres?: string;
     } | undefined;
+    /** Column tenancy, when the schema set it. The methods live on that object. */
+    readonly tenancy?: import("./tenancy.js").ColumnTenancy;
+    /**
+     * Opt-in methods for the client and table handles.
+     *
+     * Absent when the schema uses none, so a featureless app does not carry the key.
+     */
+    readonly hooks?: readonly SchemaHook[];
 };

package/dist/dialects/pg/operator-fit.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Which operators a column type accepts (spec §10.1).
+ *
+ * The read and write paths share this check. A mismatch is OKM1124 and names
+ * the column type and the operators it accepts. Values stay parameters.
+ * A path, key, or regconfig that would be interpolated is checked here first.
+ */
+/** Column family the operator table uses. */
+export type OperatorFamily = "text" | "array" | "json" | "jsonb" | "range" | "tsvector" | "scalar";
+/**
+ * Classifies a catalog type.
+ *
+ * @param dataType - Column `dataType`
+ * @returns The operator family
+ */
+export declare function columnFamily(dataType: string): OperatorFamily;
+/**
+ * Rejects an operator the column type does not accept.
+ *
+ * Operators with no entry in the fit table (equality, comparisons on a scalar)
+ * are left to the caller.
+ *
+ * @param column - Field name and catalog type
+ * @param name - Operator name
+ */
+export declare function assertOperatorFits(column: {
+    readonly field: string;
+    readonly dataType: string;
+}, name: string): void;
+/**
+ * Returns a catalog type that is safe to place in SQL, or throws.
+ *
+ * @param dataType - Column type from the catalog
+ * @param column - Field name, for the error
+ * @returns `dataType` when it matches the type pattern
+ */
+export declare function sqlType(dataType: string, column: {
+    readonly field: string;
+    readonly dataType: string;
+}): string;
+/**
+ * Rejects NUL and other control characters.
+ *
+ * An empty string is allowed. {@link assertBoundText} rejects that too.
+ *
+ * @param value - Text that will be bound
+ * @param role - What the string is, used in the error
+ */
+export declare function assertNoControl(value: string, role: string): void;
+/**
+ * Rejects an empty string, NUL, and other control characters in a key or path segment.
+ *
+ * These strings are bound, and a control character still fails before the
+ * statement is sent.
+ *
+ * @param value - Key or segment
+ * @param role - What the string is, used in the error
+ */
+export declare function assertBoundText(value: string, role: string): void;
+/**
+ * Rejects a regconfig name that is not an identifier.
+ *
+ * @param config - Text search configuration
+ */
+export declare function assertRegconfig(config: string): void;
+/**
+ * Encodes path segments or keys as a Postgres text-array literal.
+ *
+ * The literal is a parameter, not SQL text.
+ *
+ * @param values - Segments or keys
+ * @param role - What each string is
+ * @returns A `{...}` literal
+ */
+export declare function textArray(values: readonly string[], role: string): string;
+/**
+ * Element type of an array catalog type, safe to splice into SQL.
+ *
+ * @param dataType - Array type such as `text[]`
+ * @param column - Field name, for the error
+ * @returns The type with one `[]` removed
+ */
+export declare function arrayElementType(dataType: string, column: {
+    readonly field: string;
+    readonly dataType: string;
+}): string;

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

@@ -7,7 +7,7 @@
 declare const brand: unique symbol;
 declare const RUNTIME: unique symbol;
 /** Operator names the read path compiles. */
-export type OperatorName = "eq" | "lt" | "lte" | "gt" | "gte" | "between" | "startsWith" | "contains" | "endsWith" | "like" | "ilike" | "inList" | "notIn" | "not" | "or" | "has" | "none" | "every" | "inc";
+export type OperatorName = "eq" | "lt" | "lte" | "gt" | "gte" | "between" | "startsWith" | "contains" | "endsWith" | "like" | "ilike" | "inList" | "notIn" | "not" | "or" | "and" | "has" | "none" | "every" | "inc" | "containedBy" | "overlaps" | "hasKey" | "hasAnyKey" | "path" | "matches" | "json.set" | "arr.append" | "arr.remove";
 /** A tagged operator. `value` is the operand the helper stored. */
 export type Tagged<Name extends OperatorName, V> = {
     readonly [brand]: Name;
@@ -21,6 +21,44 @@ export type Compare<Name extends "lt" | "lte" | "gt" | "gte", V> = Tagged<Name,
 export type Between<V> = Tagged<"between", readonly [V, V]>;
 /** A literal pattern. `%`, `_`, and `\` in the value are escaped. */
 export type Pattern<Name extends "startsWith" | "contains" | "endsWith"> = Tagged<Name, string>;
+/** Array, jsonb, or range containment (`@>` or `<@`). */
+export type Containment<Name extends "contains" | "containedBy", V> = Tagged<Name, V>;
+/** Array or range overlap (`&&`). */
+export type Overlaps<V> = Tagged<"overlaps", V>;
+/** One jsonb key (`jsonb_exists`). */
+export type HasKey = Tagged<"hasKey", string>;
+/** Any of these jsonb keys (`jsonb_exists_any`). */
+export type HasAnyKey = Tagged<"hasAnyKey", readonly string[]>;
+/** A comparison applied to a json path (`#>>`). */
+export type PathCompare<V> = Eq<V> | Compare<"lt" | "lte" | "gt" | "gte", V>;
+/** Path segments and the comparison applied to the extracted text. */
+export type PathValue<V> = {
+    readonly segments: readonly string[];
+    readonly op: PathCompare<V>;
+};
+/** `col #>> segments` compared with `op`. */
+export type Path<V extends string | number | boolean> = Tagged<"path", PathValue<V>>;
+/** How `matches` turns query text into a tsquery. */
+export type MatchMode = "websearch" | "plain" | "phrase";
+/** Full-text query. `config` is a regconfig name when set. */
+export type MatchValue = {
+    readonly query: string;
+    readonly mode: MatchMode;
+    readonly config: string | undefined;
+};
+/** `@@` against a tsvector column. */
+export type Matches = Tagged<"matches", MatchValue>;
+/** `jsonb_set` path and the new value. */
+export type JsonSetValue<V> = {
+    readonly path: readonly string[];
+    readonly value: V;
+};
+/** Atomic JSON path write (`json.set`). */
+export type JsonSet<V> = Tagged<"json.set", JsonSetValue<V>>;
+/** `array_append` of one element. */
+export type ArrAppend<V> = Tagged<"arr.append", V>;
+/** `array_remove` of one element. */
+export type ArrRemove<V> = Tagged<"arr.remove", V>;
 /** A raw `LIKE` or `ILIKE` pattern. The caller owns the wildcards. */
 export type RawPattern<Name extends "like" | "ilike"> = Tagged<Name, string>;
 /** Membership. An empty list matches nothing. */

package/dist/dialects/pg/ops/arr-append.d.ts

@@ -0,0 +1,9 @@
+import { type ArrAppend } from "../operators.js";
+/**
+ * Appends one element (`array_append`).
+ *
+ * @typeParam V - Element
+ * @param value - Element to add
+ * @returns A tagged operator
+ */
+export declare function append<const V>(value: V): ArrAppend<V>;

package/dist/dialects/pg/ops/arr-ns.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Atomic array writes.
+ *
+ * `append` and `remove` live in their own files, so importing one drops the other.
+ */
+export { append } from "./arr-append.js";
+export { remove } from "./arr-remove.js";

package/dist/dialects/pg/ops/arr-remove.d.ts

@@ -0,0 +1,9 @@
+import { type ArrRemove } from "../operators.js";
+/**
+ * Removes every equal element (`array_remove`).
+ *
+ * @typeParam V - Element
+ * @param value - Element to remove
+ * @returns A tagged operator
+ */
+export declare function remove<const V>(value: V): ArrRemove<V>;

package/dist/dialects/pg/ops/containedBy.d.ts

@@ -0,0 +1,9 @@
+import { type Containment } from "../operators.js";
+/**
+ * Contained by (`<@`) for an array, jsonb, or range column.
+ *
+ * @typeParam V - Operand
+ * @param value - Containing value
+ * @returns A tagged operator
+ */
+export declare function containedBy<const V>(value: V): Containment<"containedBy", V>;

package/dist/dialects/pg/ops/contains.d.ts

@@ -1,8 +1,12 @@
-import { type Pattern } from "../operators.js";
+import { type Tagged } from "../operators.js";
 /**
- * Case-sensitive substring. `%`, `_`, and `\` in `value` are escaped.
+ * Substring on text, or containment (`@>`) on an array, jsonb, or range.
  *
- * @param value - Literal substring
+ * On text, `%`, `_`, and `\` in `value` are escaped. On the other types the
+ * value is a parameter cast to the column type.
+ *
+ * @typeParam V - Operand
+ * @param value - Substring or contained value
  * @returns A tagged operator
  */
-export declare function contains(value: string): Pattern<"contains">;
+export declare function contains<const V>(value: V): Tagged<"contains", V>;

package/dist/dialects/pg/ops/hasAnyKey.d.ts

@@ -0,0 +1,8 @@
+import { type HasAnyKey } from "../operators.js";
+/**
+ * jsonb key existence for any of `keys`. Compiled as `jsonb_exists_any`.
+ *
+ * @param keys - Object keys
+ * @returns A tagged operator
+ */
+export declare function hasAnyKey(keys: readonly string[]): HasAnyKey;

package/dist/dialects/pg/ops/hasKey.d.ts

@@ -0,0 +1,8 @@
+import { type HasKey } from "../operators.js";
+/**
+ * jsonb key existence. Compiled as `jsonb_exists`, so `?` never enters SQL text.
+ *
+ * @param key - Object key
+ * @returns A tagged operator
+ */
+export declare function hasKey(key: string): HasKey;

package/dist/dialects/pg/ops/json-ns.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Atomic JSON writes.
+ *
+ * One export per file, so `set` does not pull array operators.
+ */
+export { set } from "./json-set.js";

package/dist/dialects/pg/ops/json-set.d.ts

@@ -0,0 +1,12 @@
+import { type JsonSet } from "../operators.js";
+/**
+ * Atomic JSON path write, the `set` member of the `json` namespace (spec §11).
+ *
+ * The path is bound as `text[]` and the value as jsonb.
+ *
+ * @typeParam V - New value
+ * @param path - Path, one segment per element
+ * @param value - Value stored at that path
+ * @returns A tagged operator
+ */
+export declare function set<const V>(path: readonly string[], value: V): JsonSet<V>;

package/dist/dialects/pg/ops/matches.d.ts

@@ -0,0 +1,16 @@
+import { type MatchMode, type Matches } from "../operators.js";
+/**
+ * Full-text match (`@@`) for a tsvector column.
+ *
+ * The default mode is `websearch_to_tsquery`, which does not throw on user
+ * input. `"plain"` uses `plainto_tsquery` and `"phrase"` uses `phraseto_tsquery`.
+ * A text column is not searched here.
+ *
+ * @param query - Search text
+ * @param options - Mode and regconfig name
+ * @returns A tagged operator
+ */
+export declare function matches(query: string, options?: {
+    readonly mode?: MatchMode;
+    readonly config?: string;
+}): Matches;

package/dist/dialects/pg/ops/overlaps.d.ts

@@ -0,0 +1,9 @@
+import { type Overlaps } from "../operators.js";
+/**
+ * Overlap (`&&`) for an array or range column.
+ *
+ * @typeParam V - Operand
+ * @param value - Value that must overlap the column
+ * @returns A tagged operator
+ */
+export declare function overlaps<const V>(value: V): Overlaps<V>;

package/dist/dialects/pg/ops/path.d.ts

@@ -0,0 +1,13 @@
+import { type Path, type PathCompare } from "../operators.js";
+/**
+ * Compares the text at `segments` (`#>>`) with `op`.
+ *
+ * The operand of `op` picks the cast: number to numeric, boolean to boolean,
+ * string to text. Segments are bound as `text[]`.
+ *
+ * @typeParam V - Compared value
+ * @param segments - Path, one segment per element
+ * @param op - Comparison. `eq`, `lt`, `lte`, `gt`, or `gte`
+ * @returns A tagged operator
+ */
+export declare function path<const V extends string | number | boolean>(segments: readonly string[], op: PathCompare<V>): Path<V>;

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

@@ -0,0 +1,76 @@
+/**
+ * Preset types and the names a preset may not take (spec section 6.2, D41, D125).
+ *
+ * A preset is a named, typed refinement of a table: `tasks.pending()`. It gets
+ * a builder with one additive method, `where`, and returns that builder. The
+ * builder has no method that removes or replaces a predicate, so a preset can
+ * only narrow what the caller, tenancy, and the active set already allow.
+ *
+ * Only types and one list live here. The code that runs presets loads on the
+ * first call (`runtime/presets.ts`).
+ */
+import type { Or } from "./operators.js";
+import type { FieldWhere } from "./where.js";
+/**
+ * What a preset receives.
+ *
+ * Every method adds. There is no method that removes or replaces a predicate
+ * (D125, D126), and the tenant and active-set predicates are not in the
+ * builder at all: the planner puts them around it.
+ *
+ * @typeParam Row - The table's row
+ */
+export type PresetQuery<Row> = {
+    /**
+     * Adds a predicate, joined with the others by AND.
+     *
+     * Earlier predicates stay, whether the caller's, another preset's, or this
+     * preset's own.
+     *
+     * @param filter - Fields and operators, or `or(...)`
+     * @returns The same builder
+     */
+    where(filter: FieldWhere<Row> | Or<FieldWhere<Row>>): PresetQuery<Row>;
+};
+/**
+ * One preset: the builder first, then the preset's own typed arguments.
+ *
+ * @typeParam Row - The table's row
+ */
+export type Preset<Row> = (q: PresetQuery<Row>, ...args: never[]) => PresetQuery<Row>;
+/**
+ * Names a preset may not take (OKM1040).
+ *
+ * The first group are client methods. The second is reserved for later
+ * releases. `then` would make a table handle look like a promise.
+ */
+export type ReservedPreset = "find" | "one" | "page" | "aggregate" | "count" | "exists" | "insert" | "update" | "delete" | "archive" | "restore" | "withArchived" | "onlyArchived" | "then" | "lock" | "watch" | "subscribe" | "stream" | "inspect" | "explain" | "with" | "for" | "as";
+/**
+ * The `presets` option. A reserved name is a type error here, and OKM1040 when
+ * the schema is used.
+ *
+ * @typeParam Row - The table's row
+ */
+export type PresetMap<Row> = {
+    readonly [name: string]: Preset<Row>;
+} & {
+    readonly [N in ReservedPreset]?: never;
+};
+/** Names {@link ReservedPreset} lists, for the runtime check. */
+export declare const RESERVED_PRESETS: ReadonlySet<string>;
+/**
+ * Throws OKM1040 when a preset name is a client method or reserved.
+ *
+ * @param names - Preset names from one table or one trait
+ * @param where - What defines them, for the message: `table tasks` or `trait softDelete`
+ */
+export declare function checkPresetNames(names: Iterable<string>, where: string): void;
+/**
+ * Throws OKM1040 for a preset name defined by two sources.
+ *
+ * @param name - The preset name
+ * @param table - Table that ends up with both
+ * @param first - What defined it first: `table tasks` or `trait softDelete`
+ * @param second - What defines it again
+ */
+export declare function duplicatePreset(name: string, table: string, first: string, second: string): never;