okmodel 0.6.0 → 0.7.0

package/dist/runtime/plan.d.ts

@@ -8,7 +8,7 @@ import { type QueryCode } from "../contracts/error.js";
 import { type OperatorName } from "../dialects/pg/operators.js";
 import { type ColumnModel, type QuerySchema, type RelationModel, type TableModel } from "../dialects/pg/model.js";
 /** A read the caller asked for. */
-export type ReadOp = "find" | "one" | "count" | "exists" | "aggregate";
+export type ReadOp = "find" | "one" | "count" | "exists" | "aggregate" | "descendants" | "ancestors";
 /** Routing constraint chosen before execute. */
 export type RouteConstraint = "auto" | "primary" | "replica";
 /**
@@ -25,7 +25,7 @@ export type CallScope = {
 /** Writes one more `where` condition after the tenant and active-set predicates. */
 export type Keyset = (sink: Sink, alias: string) => void;
 /** Writes the whole statement of a read the planner does not know. */
-export type ReadBuild = (schema: QuerySchema, table: Indexed, sink: Sink, outputs: Built | undefined, call: ReadCall) => void;
+export type ReadBuild = (schema: QuerySchema, table: Indexed, sink: Sink, outputs: Built | undefined, call: ReadCall, hooks?: IncludeHooks) => void;
 /** One read call. `all` is the `.all(reason)` escape for an unbounded read. */
 export type ReadCall = {
     readonly op: ReadOp;
@@ -35,6 +35,8 @@ export type ReadCall = {
     readonly orderBy?: unknown;
     readonly limit?: unknown;
     readonly include?: unknown;
+    /** `find` and `count`. Rewritten to `matches` and `relevance` before SQL. */
+    readonly search?: unknown;
     readonly all?: string;
     /** The `after` cursor of a `page`. The condition joins the others with `and`. */
     readonly after?: Keyset;
@@ -47,6 +49,15 @@ export type ReadCall = {
     readonly timeout?: number;
     /** `"primary"` or `"replica"`. Absent means the router classifies the statement. */
     readonly route?: "primary" | "replica";
+    /**
+     * Endpoint a `.stream()` already chose.
+     *
+     * The first batch leaves `name` empty and the router fills it. Later batches
+     * pass the same object so they stay on that endpoint.
+     */
+    readonly pin?: {
+        name?: string;
+    };
     /** Set by `for()` or `unscoped()`. Absent on a schema with no tenancy. */
     readonly scope?: CallScope;
     /** Inspect lines from the tenancy object. Absent when the schema has no tenancy. */
@@ -95,6 +106,11 @@ export type ScalarOut = {
     readonly at: number;
     readonly decode: ((wire: string) => unknown) | undefined;
 };
+/** One target inside a morph include's JSON value. */
+export type MorphOut = {
+    readonly type: string;
+    readonly fields: readonly ScalarOut[];
+};
 /** A nested include. `at` is a root column for `one` and the JSON column for `many`. */
 export type IncludeOut = {
     readonly name: string;
@@ -102,6 +118,15 @@ export type IncludeOut = {
     readonly at: number;
     readonly fields: readonly ScalarOut[];
     readonly nested: readonly IncludeOut[];
+    /**
+     * Set when the include is a morph.
+     *
+     * The column at `at` is one JSON array, `[type, ...fields]`, or null.
+     */
+    readonly morph?: {
+        readonly typeKey: string;
+        readonly targets: readonly MorphOut[];
+    };
 };
 /** Columns and includes in statement order. */
 export type Outputs = {
@@ -114,6 +139,13 @@ export type IncludeHooks = {
     read(schema: QuerySchema, table: Indexed, include: unknown, all: string | undefined): readonly ParsedInclude[];
     select(include: ParsedInclude, alias: string, sink: Sink, outputs: Built | undefined, column: number): number;
     join(schema: QuerySchema, include: ParsedInclude, sink: Sink, parentAlias: string, alias: string, depth: number): void;
+    /**
+     * Reports whether an include's `where` or `orderBy` needs the operator compiler.
+     *
+     * The root check does not walk includes. This does, and only after the
+     * include planner has loaded.
+     */
+    needsOperator(schema: QuerySchema, call: ReadCall): boolean;
 };
 export type Built = {
     fields: ScalarOut[];
@@ -157,8 +189,13 @@ export type Sink = {
  * @returns Names in a stable order
  */
 export declare function readOptionNames(op: ReadOp): readonly string[];
-/** 0.2 operator SQL. Absent until that module has been imported. */
-type OperatorEmit = (column: ColumnModel, ref: string, name: OperatorName, value: unknown, sink: Sink) => void;
+/**
+ * 0.2 operator SQL. Absent until that module has been imported.
+ *
+ * `order` is set when the operator is an `orderBy` value. `relevance` writes
+ * its direction there; the same operator in `where` is refused by that module.
+ */
+type OperatorEmit = (column: ColumnModel, ref: string, name: OperatorName, value: unknown, sink: Sink, order?: true) => void;
 /**
  * Installs the 0.2 operator compiler.
  *
@@ -177,6 +214,16 @@ export declare function installOperatorSql(emit: OperatorEmit): void;
  * @returns `true` when {@link installOperatorSql} has not run and the read needs it
  */
 export declare function readNeedsOperatorSql(schema: QuerySchema, call: ReadCall): boolean;
+/**
+ * Reports whether `orderBy` holds a `relevance` value.
+ *
+ * Called before the operator compiler has loaded. The include planner uses it
+ * for a related table.
+ *
+ * @param orderBy - The caller's order
+ * @returns `true` when a value is `relevance`
+ */
+export declare function orderHasRelevance(orderBy: unknown): boolean;
 /**
  * Writes `<table> <alias> where <link to parent>` for a to-many relation.
  *
@@ -184,6 +231,18 @@ export declare function readNeedsOperatorSql(schema: QuerySchema, call: ReadCall
  * The caller adds the related table's own predicates after it.
  */
 export declare function emitRelationFrom(schema: QuerySchema, relation: RelationModel, child: Indexed, sink: Sink, parent: string, alias: string, depth: number): void;
+/**
+ * Reports whether a filter needs the operator compiler.
+ *
+ * Equality and text patterns do not. The include planner calls this for a
+ * related table.
+ *
+ * @param table - The table the filter reads
+ * @param value - A `where` value
+ * @param key - The field, when `value` is that field's operand
+ * @returns `true` when the operator compiler has to load
+ */
+export declare function needsOperatorSql(table: Indexed, value: unknown, key?: string): boolean;
 /**
  * Runs registered safety rules before planning.
  *
@@ -259,6 +318,15 @@ export declare function emitPrimaryOrder(table: Indexed, sink: Sink, alias: stri
  * @param column - The field the caller named
  */
 export declare function refuseHidden(column: ColumnModel): void;
+export declare function emitLimit(call: ReadCall, sink: Sink): void;
+/** One target branch of a morph include. */
+export type ParsedMorphTarget = {
+    readonly type: string;
+    readonly table: string;
+    readonly sql: string;
+    readonly keySql: string;
+    readonly columns: readonly ColumnModel[];
+};
 export type ParsedInclude = {
     readonly name: string;
     readonly relation: RelationModel;
@@ -270,13 +338,35 @@ export type ParsedInclude = {
     /** Index in the projected list that is null when the related row is missing. */
     readonly anchor: number;
     readonly nested: readonly ParsedInclude[];
+    /**
+     * Set when the include is a morph.
+     *
+     * Absent on every other include, so a normal include does not carry it.
+     */
+    readonly morphTo?: {
+        readonly typeKey: string;
+        readonly typeSql: string;
+        readonly idSql: string;
+        readonly targets: readonly ParsedMorphTarget[];
+    };
 };
 export declare function selectedColumns(table: Indexed, select: unknown): readonly ColumnModel[];
 export declare function parseOrder(field: string, value: unknown): {
     readonly dir: "asc" | "desc";
     readonly nulls: "first" | "last";
 };
-export declare function rejectKeys(value: Readonly<Record<string, unknown>>, accepted: readonly string[], where: string): void;
+/**
+ * Refuses a key that `accepted` does not list.
+ *
+ * A read passes `search`. `one` and `exists` then say to use `find` or
+ * `count`, instead of the generic option list.
+ *
+ * @param value - Caller options
+ * @param accepted - Names this call allows
+ * @param where - The call, named in the error
+ * @param search - When set, a rejected `search` key uses the read message
+ */
+export declare function rejectKeys(value: Readonly<Record<string, unknown>>, accepted: readonly string[], where: string, search?: true): void;
 export declare function readLimit(value: unknown): number;
 /**
  * Lets an object through only when the column's codec takes it (OKM1121).

package/dist/runtime/read-stream.d.ts

@@ -1,26 +1,23 @@
 /**
- * Server-side read cursor.
+ * Keyset batches for `.stream()` (spec §10).
  *
  * Loaded the first time `.stream()` is iterated. A find that is only awaited
- * does not load it.
+ * does not load it. Each batch is one finished `page` query: fetch, yield,
+ * then fetch the next. A `break` does not hold a connection. A server cursor
+ * is not used, so the driver `stream` flag is not read.
  */
-import type { DriverPool } from "../contracts/driver.js";
-import { OkmError, type ErrorStatuses } from "../contracts/error.js";
-import { type Plan, type ReadCall } from "./plan.js";
+import { OkmError } from "../contracts/error.js";
+import { type Mods, type Session } from "./client.js";
+import { type ArchiveView, type ReadCall } from "./plan.js";
 /**
- * Yields decoded rows from the driver's stream.
+ * Yields decoded rows, one keyset batch at a time.
  *
  * @param session - Connected pool and HTTP statuses
- * @param call - The read being streamed
- * @param prepare - Compiles the statement on first use
+ * @param call - The find being streamed
+ * @param mods - `.all` reason and presets
+ * @param view - Archive visibility
+ * @param batchOptions - `{ batch }`, or omitted for {@link DEFAULT_BATCH}
  * @param log - Attaches the session logger and returns the error
  * @returns One row at a time
  */
-export declare function streamRows(session: {
-    readonly connected: Promise<void>;
-    readonly pool: DriverPool;
-    readonly http: ErrorStatuses | undefined;
-}, call: ReadCall, prepare: () => Promise<{
-    readonly plan: Plan;
-    readonly params: readonly (string | null)[];
-}>, log: (error: OkmError) => OkmError): AsyncIterable<unknown>;
+export declare function streamRows(session: Session, call: ReadCall, mods: Mods, view: ArchiveView | undefined, batchOptions: object | undefined, log: (error: OkmError) => OkmError): AsyncIterable<unknown>;

package/dist/runtime/result-name.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Result keys a caller chooses.
+ *
+ * Loaded with the bucket chunk and the window chunk (D258). The startup
+ * graph does not import it.
+ */
+/**
+ * Refuses a result key that would shadow or replace a prototype property.
+ *
+ * Assigning `__proto__` replaces that object's prototype when the value is an
+ * object. The other names shadow methods on the row. `then` makes the row a
+ * thenable. The check runs before any SQL.
+ *
+ * @param name - The result key
+ * @param where - The call, such as `rowNumber as` or `bucket as`
+ */
+export declare function refusePrototypeKey(name: string, where: string): void;

package/dist/runtime/server-check.d.ts

@@ -17,11 +17,11 @@ export declare const versionQuery = "select current_setting('server_version_num'
 /**
  * Accepts the `server_version_num` row, or throws OKM1801, OKM1520, OKM1802, or OKM1803.
  *
- * A declared `requires` is the minimum, including a major below 15 when the
- * schema names it on purpose. With no `requires`, the floor is 15.
+ * A declared floor is the minimum. With no floor, the minimum is 15.
+ * A major below 15 is refused when the schema is built.
  *
  * @param pool - Connection that ran the version query
- * @param schema - Schema whose `requires` is the declared minimum
+ * @param schema - Schema whose floor is the declared minimum
  * @param rows - `server_version_num`, `version()`, and the `okm_meta` hash
  * @param http - Status overrides from `connect`
  * @param requireMeta - When true, a missing hash is OKM1520

package/dist/runtime/sort-bind.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Unique index `sortable()` adds.
+ *
+ * Tenancy has already widened uniques (D168), so this index names the tenant
+ * keys itself. The move and insert SQL load later, on the first call.
+ */
+import type { AnyTable } from "../dialects/pg/table.js";
+/**
+ * Adds the position unique index on tables this trait applies to.
+ *
+ * A path table is refused: the tenant key is not a column, so the index could
+ * not keep two tenants from sharing a position.
+ *
+ * @param self - The trait object `schema()` stored
+ * @param tables - Tables after the tenancy rewrite
+ * @param casing - Schema casing
+ * @param schemaTraits - Traits from `schema()`, when any were passed
+ * @param group - Field that splits the order, when `sortable` was given one
+ * @returns Tables with the index on the ones this trait applies to
+ */
+export declare function rewriteSortable(self: object, tables: readonly AnyTable[], casing: "snake" | undefined, schemaTraits: readonly object[] | undefined, group: string | undefined): readonly AnyTable[];

package/dist/runtime/sort.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Position assignment and `move`.
+ *
+ * Loaded on the first insert or move of a `sortable()` table. Positions are
+ * dense positive integers, unique inside the group (and the tenant). The
+ * advisory lock is its own statement. The next statement reads positions.
+ * Under READ COMMITTED a statement's snapshot is taken when it starts, which
+ * is before a lock in that same statement is granted, so a commit that landed
+ * while this transaction waited would be invisible.
+ */
+import type { Statement } from "../contracts/driver.js";
+import type { ColumnModel, QuerySchema } from "../dialects/pg/model.js";
+import { type ArchiveView, type CallScope, type Indexed } from "./plan.js";
+import { type RunHost } from "./tx.js";
+type Host = RunHost & {
+    readonly schema: QuerySchema;
+    readonly scope?: CallScope;
+    readonly connected?: Promise<void>;
+};
+/**
+ * Inserts rows at the end of their group.
+ *
+ * The lock statement runs first. The insert then takes `max(position) + n`
+ * from a snapshot taken after that lock is held. A writer that bypasses these
+ * statements can still race; the unique index rejects a duplicate.
+ *
+ * @param table - Target table
+ * @param columns - Columns the insert already decided to write
+ * @param rows - Stamped rows, in call order
+ * @param group - Group field, when the trait has one
+ * @param tenantFields - Tenant fields stored on this table
+ * @returns The lock, then the insert without `returning`
+ */
+export declare function insertAtEnd(table: Indexed, columns: readonly ColumnModel[], rows: readonly Record<string, unknown>[], group: string | undefined, tenantFields: readonly string[] | undefined): {
+    readonly lock: Statement;
+    readonly text: string;
+    readonly params: (string | null)[];
+};
+/**
+ * Moves one row before or after another in the same group.
+ *
+ * The result is `{ position }` after the move. A missing id is `not_found`.
+ * An anchor in another group is OKM1120 and writes nothing. The same id on
+ * both sides leaves the row where it is.
+ *
+ * @param host - Pool and schema
+ * @param tableName - Table the trait is on
+ * @param id - Primary key of the row to move, without the tenant key
+ * @param place - `{ before }` or `{ after }`, the anchor's primary key
+ * @param view - Archive visibility, when the handle narrowed it
+ * @returns The row's position after the move
+ */
+export declare function move(host: Host, tableName: string, id: unknown, place: unknown, view: ArchiveView | undefined): Promise<{
+    readonly position: number;
+}>;
+export {};

package/dist/runtime/sync.d.ts

@@ -0,0 +1,70 @@
+/**
+ * `sync` (spec §11, §13 tool 10).
+ *
+ * One transaction sets a to-many relation to an exact set of ids. The first
+ * statement locks the parent row. The write is a second statement, so a sync
+ * that waited for that lock sees the links the previous sync committed. A join table
+ * gains and loses link rows. A one-to-many sets or clears a nullable foreign
+ * key and leaves the related row in place. A link that would have to delete
+ * that row is refused. Duplicate ids count once. An id that is not in the
+ * related table, or a parent id that is not in this table, writes nothing and
+ * throws `not_found`. The parent row is locked, so two syncs of the same id
+ * run one after the other.
+ *
+ * Loaded on the first call.
+ */
+import type { Statement } from "../contracts/driver.js";
+import type { PresetUse } from "../dialects/pg/model.js";
+import { type Mods as ReadMods, type Session } from "./client.js";
+import { type ArchiveView } from "./plan.js";
+type Mods = {
+    readonly expect?: number;
+    readonly archive?: ArchiveView | undefined;
+    readonly uses?: PresetUse | undefined;
+};
+/**
+ * Runs one `sync`.
+ *
+ * @param session - Client session
+ * @param table - Table that owns the relation
+ * @param id - Primary key of that row
+ * @param relation - To-many relation name
+ * @param ids - Related primary keys the relation should hold
+ * @param options - `expect`, `signal`, and `timeout`
+ * @param mods - Chained `expect`, archive visibility, and presets
+ * @returns The ids whose links were added or removed
+ */
+export declare function execute(session: Session, table: string, id: unknown, relation: unknown, ids: unknown, options: object | undefined, mods: Mods): Promise<{
+    readonly added: readonly unknown[];
+    readonly removed: readonly unknown[];
+}>;
+/**
+ * The statement `sync` would run.
+ *
+ * @param session - Client session
+ * @param table - Table that owns the relation
+ * @param id - Primary key of that row
+ * @param relation - To-many relation name
+ * @param ids - Related primary keys the relation should hold
+ * @param options - `expect`, `signal`, and `timeout`
+ * @param mods - Chained `expect`, archive visibility, and presets
+ * @returns One statement
+ */
+export declare function explain(session: Session, table: string, id: unknown, relation: unknown, ids: unknown, options: object | undefined, mods: Mods): Promise<{
+    readonly statements: readonly Statement[];
+}>;
+/**
+ * The handle for one `sync`.
+ *
+ * Await runs the change. `sql` shows the lock and the write. `expect` lives on
+ * the outer handle, which calls this again with `mods.expect` set.
+ *
+ * @param session - Client session
+ * @param table - Table that owns the relation
+ * @param input - `id`, `relation`, `ids`, and `options`
+ * @param mods - Presets, plus `expect` when the outer handle chained it
+ * @param view - Archive view. The same value a read on this handle uses
+ * @returns A handle. The value is `{ added, removed }`
+ */
+export declare function build(session: Session, table: string, input: object, mods: ReadMods, view: ArchiveView | undefined): Promise<unknown> & Record<string, unknown>;
+export {};

package/dist/runtime/tenancy/index.js

@@ -8,10 +8,10 @@ import {
 } from "../../shared/bdk4sty6.js";
 import {
   isRelationCall
-} from "../../shared/k68eedmy.js";
+} from "../../shared/exn3sd90.js";
 import {
   uuid2
-} from "../../shared/2jd1sn0e.js";
+} from "../../shared/hyh73qk6.js";
 import {
   index2,
   snakeCase
@@ -28,7 +28,7 @@ import {
 } from "../../shared/94ez8kzh.js";
 import {
   quote
-} from "../../shared/2z7wv5tj.js";
+} from "../../shared/67txcrcw.js";
 import {
   assertIdentifier2
 } from "../../shared/nfzc5z0w.js";
@@ -233,7 +233,8 @@ function rewriteTenant(keys, keyColumns, item, tables, kind, tenants, exemptions
       ...options,
       ...primaryKey !== undefined ? { primaryKey } : {},
       ...Object.keys(unique).length > 0 ? { unique } : {},
-      ...indexes !== undefined ? { indexes } : {}
+      ...indexes !== undefined ? { indexes } : {},
+      tenantKeys: keys
     }
   };
   return declared !== undefined && declared.length > 0 ? markPathEndpoint(rewritten) : rewritten;
@@ -1667,7 +1668,8 @@ function rewriteTenant2(key, column, item, tables, kind, tenants, exemptions, ex
       ...options,
       ...primaryKey !== undefined ? { primaryKey } : {},
       ...Object.keys(unique).length > 0 ? { unique } : {},
-      ...indexes !== undefined ? { indexes } : {}
+      ...indexes !== undefined ? { indexes } : {},
+      tenantKeys: [key]
     }
   };
   return noted !== undefined && noted.length > 0 ? markPathEndpoint(rewritten) : rewritten;

package/dist/runtime/text-search.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `search` on `find` and `count`.
+ *
+ * Loaded on the first call that passes `search`. It rewrites the call into
+ * `matches` and, when `find` has no `orderBy`, `relevance` plus the primary
+ * key. The SQL compiler is the one those helpers already use.
+ */
+import type { QuerySchema } from "../dialects/pg/model.js";
+import { type ReadCall } from "./plan.js";
+/**
+ * Rewrites `search` into `matches` and `relevance`.
+ *
+ * `count` keeps the caller's order, which it does not emit. An explicit
+ * `orderBy` on `find` replaces the automatic ranking.
+ *
+ * @param schema - Connected schema
+ * @param call - The read, with `search` set
+ * @returns The same read, without `search`
+ */
+export declare function applyTextSearch(schema: QuerySchema, call: ReadCall): ReadCall;

package/dist/runtime/traits/index.d.ts

@@ -5,6 +5,7 @@
  * does not import it does not load these columns.
  */
 import { type PresetMap } from "../../dialects/pg/preset.js";
+import type { QuerySchema, SchemaHookCtx } from "../../dialects/pg/model.js";
 import type { AnyTable, RowFrom } from "../../dialects/pg/table.js";
 import { attachArchive } from "../archive-handle.js";
 import { type Trait, type TraitContext, type TraitModel } from "../../dialects/pg/trait.js";
@@ -131,3 +132,82 @@ export declare function archivable(options?: ArchivableOptions): {
     rewrite(tables: readonly AnyTable[], casing: "snake" | undefined, schemaTraits: readonly object[] | undefined): readonly AnyTable[];
     hook: typeof attachArchive;
 };
+/**
+ * Adds `version` and checks it on every update.
+ *
+ * The column starts at 1. An update passes the version it read and the write
+ * bumps it. A stale version is category `conflict` and changes nothing.
+ * Input cannot set `version`.
+ *
+ * @returns The versioned trait
+ */
+export declare function versioned(): {
+    readonly name: string;
+    readonly fields: {
+        readonly version: import("../../dialects/pg/column.js").ColumnBuilder<number, import("../../dialects/pg/column.js").FlagTrue<import("../../dialects/pg/column.js").FlagTrue<import("../../dialects/pg/column.js").PlainFlags, "hasDefault">, "guarded">>;
+    };
+    readonly touch?: readonly "version"[];
+    readonly sealed?: readonly "version"[];
+    apply(model: TraitModel, ctx: TraitContext): void;
+    contribute(peers: unknown, built: unknown): readonly unknown[];
+};
+/**
+ * Adds `position` and `move`.
+ *
+ * New rows go at the end of the group. `move` places a row before or after
+ * another in that group. `find` and `page` order by `position` when the
+ * caller does not pass `orderBy`. Input cannot set `position`.
+ *
+ * @param groupBy - Column that splits the order. Omit it for one list
+ * @returns The sortable trait
+ */
+export declare function sortable(groupBy?: string): {
+    name: string;
+    fields: {
+        readonly position: import("../../dialects/pg/column.js").ColumnBuilder<number, import("../../dialects/pg/column.js").FlagTrue<import("../../dialects/pg/column.js").PlainFlags, "guarded">>;
+    };
+    touch?: readonly "position"[];
+    sealed?: readonly "position"[];
+    contribute(peers: unknown, built: unknown): readonly unknown[];
+    group?: string;
+    "~sort": true;
+    apply(model: TraitModel, ctx: TraitContext): void;
+    /**
+     * Adds the unique position index after tenancy has widened uniques.
+     *
+     * @param tables - Tables after the tenancy rewrite
+     * @param casing - Schema casing
+     * @param schemaTraits - Traits from `schema()`, when any were passed
+     * @returns The rewritten tables
+     */
+    rewrite(tables: readonly AnyTable[], casing: "snake" | undefined, schemaTraits: readonly object[] | undefined): readonly AnyTable[];
+    hook: typeof attachSort;
+};
+/**
+ * Adds `move` and the default position order on a sortable table.
+ *
+ * @param target - The table handle being built
+ * @param ctx - Table name and the session
+ */
+declare function attachSort(target: Record<string, unknown>, ctx: SchemaHookCtx): void;
+declare module "../types.js" {
+    interface TableExtras<S extends QuerySchema, K extends keyof S["~byName"] & string> {
+        /**
+         * Moves one row before or after another in the same group.
+         *
+         * The result is the row's position after the move. A missing id is
+         * `not_found`. An anchor in another group is OKM1120.
+         *
+         * @param id - Primary key of the row to move, without the tenant key
+         * @param place - `{ before }` or `{ after }`, the anchor's primary key
+         * @returns The position after the move
+         */
+        move(id: unknown, place: {
+            readonly before: unknown;
+        } | {
+            readonly after: unknown;
+        }): Promise<{
+            readonly position: number;
+        }>;
+    }
+}