okmodel 0.6.0 → 0.8.0

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

@@ -52,6 +52,17 @@ export declare function introspectSchema(runner: CatalogQuery, concrete: string,
  * Types only, comma-separated, no spaces. Argument names are left out.
  */
 export declare const FUNCTION_ARG_TYPES = "replace(oidvectortypes(p.proargtypes), ' ', '')";
+/**
+ * The `BEGIN ATOMIC` block inside `pg_get_functiondef`.
+ *
+ * A definition that does not contain that block is returned whole. The slice
+ * stops at the last `END`, which is the block closer. A `CASE` closer earlier
+ * in the reprint stays inside the block.
+ *
+ * @param definition - `pg_get_functiondef` text
+ * @returns The body introspection stores
+ */
+export declare function atomicBody(definition: string): string;
 /**
  * Applies one expression as a check and reads Postgres's reprint.
  *

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

@@ -8,15 +8,18 @@ export type IdDefault = "uuidv7" | "uuidv4" | "none";
 /**
  * Primary key.
  *
- * 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.
+ * With no options, the database default is `gen_random_uuid()` unless
+ * `schema({ defaults: { id } })` says otherwise. That function is built in
+ * from Postgres 13, so a bare call works on every supported major. `uuidv7`
+ * stores `uuidv7()` and needs Postgres 18 (`minPostgres: 18`). Pick it for a large write-heavy
+ * table: the ids are time-ordered and the index stays local. Random ids are
+ * fine elsewhere. `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()`
+ * @param options - Which default to store. Omitted means the schema default, or `gen_random_uuid()`
  * @returns An id column
  */
 export declare function id(): ColumnBuilder<string, IdFlags>;

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

@@ -63,6 +63,39 @@ export type ColumnModel = {
      */
     readonly accepts?: readonly string[] | undefined;
 };
+/**
+ * One table a morph include can return.
+ *
+ * `type` is the table's TypeScript name, which is what the type column stores.
+ */
+export type MorphTarget = {
+    readonly type: string;
+    readonly table: string;
+    /** SQL name of the target table. */
+    readonly sql: string;
+    /** SQL name of the target's single primary-key column. */
+    readonly keySql: string;
+};
+/**
+ * A polymorphic pair: a type column and an id column.
+ *
+ * `to` is the owner side (one of several tables). `many` is the reverse on a target.
+ * Absent on every other relation, so a normal relation does not carry it.
+ */
+export type MorphModel = {
+    readonly direction: "to" | "many";
+    /** Column stem. The fields are `${name}Type` and `${name}Id`. */
+    readonly name: string;
+    readonly typeField: string;
+    readonly idField: string;
+    /** SQL name of the type column. */
+    readonly typeSql: string;
+    /** SQL name of the id column. */
+    readonly idSql: string;
+    /** On a reverse many, the table name stored in the type column. */
+    readonly typeValue?: string;
+    readonly targets: readonly MorphTarget[];
+};
 /**
  * A resolved relation.
  *
@@ -77,6 +110,13 @@ export type RelationModel = {
     readonly local: readonly string[];
     /** SQL names on the related table. */
     readonly remote: readonly string[];
+    /**
+     * Set on a morph relation.
+     *
+     * The include planner reads `to`. A reverse many reads `many` and emits
+     * through {@link RelationModel.through}.
+     */
+    readonly morph?: MorphModel;
     /**
      * Set on a `manyThrough` relation.
      *

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

@@ -0,0 +1,43 @@
+/**
+ * Resolver and emitters of a `morph` relation.
+ *
+ * The relation object carries both. `schema()` calls the resolver, and the
+ * planner calls the emitter with its own helpers, so a schema that never
+ * calls `morph` or `morphMany` does not ship this module. A target in another
+ * tenant or archived never shows: the include planner applies those predicates
+ * to each target, the same way it does for any relation.
+ */
+import type { RelationModel } from "./model.js";
+import type { RelationScope } from "./relations.js";
+/**
+ * Resolves `morph(name, targets)` on the table that holds the type and id columns.
+ *
+ * @param scope - What `schema()` knows
+ * @param name - Column stem: `${name}Type` and `${name}Id`
+ * @param targets - Closed list of target table names
+ * @returns The resolved to-one relation
+ */
+export declare function resolveMorph(scope: RelationScope, name: string, targets: readonly string[]): RelationModel;
+/**
+ * Resolves `morphMany(table, name)` on a target table.
+ *
+ * The many reads the owner table's type and id columns. The owner must declare
+ * `morph(name, targets)` and list this table.
+ *
+ * @param scope - What `schema()` knows. `owner` is the target table
+ * @param table - Table that holds the type and id columns
+ * @param name - Column stem declared on that table
+ * @returns The resolved to-many relation
+ */
+export declare function resolveMorphMany(scope: RelationScope, table: string, name: string): RelationModel;
+/**
+ * Refuses `morphTo` when the name, type, or id is missing.
+ *
+ * `null` used to throw a TypeError on `.length`. An empty name or type stays
+ * OKM1020. A null or non-string id, or a null type, is OKM1120.
+ *
+ * @param name - Column stem
+ * @param type - Target table name
+ * @param id - That table's primary key
+ */
+export declare function assertMorphTo(name: unknown, type: unknown, id: unknown): void;

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

@@ -58,9 +58,9 @@ export declare function assertNoControl(value: string, role: string): void;
  */
 export declare function assertBoundText(value: string, role: string): void;
 /**
- * Rejects a regconfig name that is not an identifier.
+ * Rejects a text search language that is not an identifier.
  *
- * @param config - Text search configuration
+ * @param config - Language name, such as `english`
  */
 export declare function assertRegconfig(config: string): void;
 /**

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" | "and" | "has" | "none" | "every" | "inc" | "containedBy" | "overlaps" | "hasKey" | "hasAnyKey" | "path" | "matches" | "similar" | "wordSimilar" | "json.set" | "arr.append" | "arr.remove";
+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" | "relevance" | "similar" | "wordSimilar" | "sql" | "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;
@@ -38,16 +38,23 @@ export type PathValue<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. */
+/**
+ * How search text is matched.
+ *
+ * `natural` is web-search style. `all-words` requires every word. `phrase`
+ * keeps the words in order. `advanced` is PostgreSQL query syntax.
+ */
+export type SearchMatch = "natural" | "all-words" | "phrase" | "advanced";
+/** Text to look for, how to match it, and the text search language when one was passed. */
 export type MatchValue = {
     readonly query: string;
-    readonly mode: MatchMode;
-    readonly config: string | undefined;
+    readonly match: SearchMatch;
+    readonly language: string | undefined;
 };
-/** `@@` against a tsvector column. */
+/** `@@` against a search column. */
 export type Matches = Tagged<"matches", MatchValue>;
+/** Order by how well a search column matches. Most relevant first. */
+export type Relevance = Tagged<"relevance", MatchValue>;
 /** Text stored on a `pg_trgm` operator. `schema` is the extension's install schema. */
 export type TrigramQuery = {
     readonly query: string;

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

@@ -0,0 +1,65 @@
+/**
+ * Time bucket for `aggregate` `groupBy` (spec §10, §13 tool 4).
+ *
+ * The brand is a symbol. JSON cannot create one, so a request cannot add a
+ * bucket. A plain object in `groupBy` stays OKM1120. The SQL loads with the
+ * first `aggregate()` whose `groupBy` contains a bucket.
+ */
+declare const brand: unique symbol;
+/** Calendar and clock units `bucket` accepts. */
+export type BucketUnit = "second" | "minute" | "hour" | "day" | "week" | "month" | "quarter" | "year";
+/** Week that starts on Monday (ISO), Sunday, or Saturday. */
+export type WeekStart = "monday" | "sunday" | "saturday";
+/**
+ * A `bucket()` call.
+ *
+ * `C` is the column, `U` the unit, and `A` the result key.
+ */
+export type Bucket<C extends string, U extends string, A extends string> = {
+    readonly [brand]: C;
+    readonly unit: U;
+    readonly as: A;
+};
+/** What {@link bucket} stores. The aggregate chunk reads this. */
+export type BucketInput = {
+    readonly column: unknown;
+    readonly unit: unknown;
+    readonly as: unknown;
+    readonly tz: unknown;
+    readonly weekStart: unknown;
+};
+/**
+ * Groups a timestamp or date column by a calendar or clock unit.
+ *
+ * `tz` is required for `timestamptz` and refused for `date`. `timestamp`
+ * without a zone is refused. `as` is the result key. `__proto__`, `constructor`,
+ * `toString`, and `hasOwnProperty` are refused when the aggregate runs.
+ * `weekStart` applies only
+ * to `week` and defaults to Monday. A NULL timestamp is its own group: the
+ * `as` key is present and the value is null.
+ *
+ * Day, week, month, quarter, and year come back as `Temporal.PlainDate` (the
+ * local date the period starts). Second, minute, and hour come back as
+ * `Temporal.Instant` (the period start).
+ *
+ * @typeParam C - Column name
+ * @typeParam U - Unit
+ * @typeParam A - Result key
+ * @param column - Field to bucket
+ * @param unit - Period
+ * @param options - Zone, result key, and week start
+ * @returns A tagged bucket. Pass it in `groupBy`
+ */
+export declare function bucket<const C extends string, const U extends BucketUnit, const A extends string>(column: C, unit: U, options: {
+    readonly tz?: string;
+    readonly as: A;
+    readonly weekStart?: WeekStart;
+}): Bucket<C, U, A>;
+/**
+ * Reports whether `value` is a {@link bucket} call.
+ *
+ * @param value - One `groupBy` entry
+ * @returns `true` when {@link bucket} created it
+ */
+export declare function isBucket(value: unknown): value is BucketInput;
+export {};

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

@@ -0,0 +1,119 @@
+/**
+ * Composed SQL fragments (rule 15, D266).
+ *
+ * The check-constraint `sql` tag stays a string. A query fragment is a tagged
+ * operator named `sql`, so the planner compiles it on the existing lazy
+ * operator path. Values are parameters. `ident` stores a name the compiler
+ * quotes. `fragment.column` is the where field the fragment is attached to.
+ */
+import { type Eq } from "../operators.js";
+import type { Window } from "./window.js";
+declare const identBrand: unique symbol;
+declare const columnBrand: unique symbol;
+/** One piece of a fragment. The compiler walks this list. */
+export type FragmentPart = {
+    readonly k: "t";
+    readonly s: string;
+} | {
+    readonly k: "p";
+    readonly v: string;
+} | {
+    readonly k: "n";
+} | {
+    readonly k: "i";
+    readonly n: string;
+} | {
+    readonly k: "c";
+} | {
+    readonly k: "f";
+    readonly parts: readonly FragmentPart[];
+};
+/** A name `ident` stored. The compiler quotes it. */
+export type FragmentIdent = {
+    readonly [identBrand]: string;
+};
+/** The where field a fragment is attached to. */
+export type FragmentColumn = {
+    readonly [columnBrand]: true;
+};
+/**
+ * A composed fragment.
+ *
+ * It is a where operand. `.as(name)` is the select form, and that result is a
+ * number.
+ */
+export type Fragment = Eq<never> & {
+    /**
+     * Names the select result.
+     *
+     * @typeParam A - Result key
+     * @param name - Result key. Not a column name
+     * @returns A select entry
+     */
+    as<const A extends string>(name: A): Window<A, number>;
+};
+/**
+ * Reports whether `value` is the part list `fragment` stored.
+ *
+ * @param value - Operator operand
+ * @returns `true` when every part has a known kind
+ */
+export declare function isFragmentParts(value: unknown): value is readonly FragmentPart[];
+/**
+ * Reads a select fragment.
+ *
+ * @param value - One `select` entry
+ * @returns The result name and the parts, or `undefined` when it is not a fragment
+ */
+export declare function readSelectFragment(value: unknown): {
+    readonly as: string;
+    readonly parts: readonly FragmentPart[];
+    readonly textual?: true;
+} | undefined;
+/**
+ * A function call stored as a `sql` fragment.
+ *
+ * The planner compiles it on the same path as {@link fragment}. `textual`
+ * makes `.as(name)` keep the wire string. A numeric call parses a number.
+ *
+ * @param parts - Expression parts, including the function name
+ * @param textual - When true, a select result stays text
+ * @returns A where operand. Call `.as(name)` to use it in `select`
+ */
+export declare function sqlExpression(parts: readonly FragmentPart[], textual?: boolean): Fragment;
+/**
+ * Reads the field name `ident` stored.
+ *
+ * @param value - A fragment interpolation
+ * @returns The field name, or `undefined` when `value` is not an ident
+ */
+export declare function identName(value: unknown): string | undefined;
+/**
+ * A composed SQL fragment.
+ *
+ * `column` is the where field this fragment is attached to.
+ */
+export declare const fragment: {
+    /**
+     * Builds a composed SQL fragment.
+     *
+     * @param strings - Literal SQL
+     * @param values - Parameters, identifiers, the column, or nested fragments
+     * @returns A where operand
+     */
+    (strings: TemplateStringsArray, ...values: readonly unknown[]): Fragment;
+    /** The where field this fragment is attached to, quoted by the compiler. */
+    readonly column: FragmentColumn;
+};
+/**
+ * Stores a field name for a fragment to resolve.
+ *
+ * The name is the TypeScript field, the same name `where` uses. Casing and
+ * `sqlName` are applied when the compiler quotes the column. A hidden field
+ * is OKM1120 at planning. Empty names and control characters are OKM1122.
+ *
+ * @param name - Field name
+ * @returns A value `fragment` resolves against the table
+ */
+export declare function ident(name: string): FragmentIdent;
+export {};

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

@@ -2,9 +2,9 @@ import { type Tagged } from "../operators.js";
 /** Adds to the stored number. `undefined` in `set` still leaves the field unchanged. */
 export type Inc<V> = Tagged<"inc", V>;
 /**
- * Atomic increment used in `update` `set` (spec §11).
+ * Adds to a stored number in `update` `set` (spec §11).
  *
- * JSON and array operators are not this helper.
+ * A null number stays null. JSON and array operators are not this helper.
  *
  * @typeParam V - Amount
  * @param value - Amount to add

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

@@ -0,0 +1,49 @@
+/**
+ * Typed raw SQL and `explain()` (P103, P104, D268).
+ *
+ * Exported from `okmodel/pg`. An app that does not import them drops this
+ * module. The table handle carries the session under `Symbol.for("okm.lane")`.
+ * The statement class is explicit. Parameters come from the fragment. The
+ * tenant predicate, when it applies, is written outside the fragment.
+ */
+/**
+ * What `explain()` returns.
+ *
+ * `plan` is null in production, and `params` is empty there.
+ */
+export type ExplainResult = {
+    /** The statement `explain` describes. */
+    readonly text: string;
+    /** Bound parameters. Empty in production. */
+    readonly params: readonly (string | null)[];
+    /** `EXPLAIN` lines, or null when the statement was not sent. */
+    readonly plan: readonly string[] | null;
+};
+/**
+ * Runs one typed raw statement on a table handle.
+ *
+ * `cls` is constructed once per row. Own enumerable keys of that instance, in
+ * order, are the result columns. A key that is a field of the table uses that
+ * field's decode. Any other key uses the initializer: a number, a boolean, or
+ * driver text. `null` stays `null`.
+ *
+ * @typeParam C - Result class. Each row is an instance
+ * @param handle - Table handle (`db.notes`, including one from `for()`)
+ * @param cls - Class with an initializer on every result column
+ * @param statement - `"read"` or `"write"`
+ * @param source - A `fragment` template. Identifiers are `ident(name)`
+ * @returns One instance per row
+ */
+export declare function raw<C extends new () => object>(handle: object, cls: C, statement: "read" | "write", source: unknown): Promise<InstanceType<C>[]>;
+/**
+ * Describes a query.
+ *
+ * Outside production this sends `EXPLAIN` and returns the lines. In production
+ * (`NODE_ENV` is `"production"`) it does not send the statement. `plan` is
+ * null and `params` is empty.
+ *
+ * @param handle - Table handle that owns the query's session
+ * @param query - A query from that table. `sql()` is the statement
+ * @returns The statement and, outside production, the plan lines
+ */
+export declare function explain(handle: object, query: object): Promise<ExplainResult>;

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

@@ -1,16 +1,13 @@
-import { type MatchMode, type Matches } from "../operators.js";
+import { type Matches } from "../operators.js";
+import { type SearchOptions } from "./search-query.js";
 /**
- * Full-text match (`@@`) for a tsvector column.
+ * Full-text match for a search 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.
+ * The default match is natural, which does not throw on user input. A plain
+ * text column is not searched here. `relevance` orders by the same match.
  *
- * @param query - Search text
- * @param options - Mode and regconfig name
- * @returns A tagged operator
+ * @param query - Text to look for
+ * @param options - How to match, and the text search language
+ * @returns A tagged operator for `where`
  */
-export declare function matches(query: string, options?: {
-    readonly mode?: MatchMode;
-    readonly config?: string;
-}): Matches;
+export declare function matches(query: string, options?: SearchOptions): Matches;

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

@@ -0,0 +1,13 @@
+import { type Relevance } from "../operators.js";
+import { type SearchOptions } from "./search-query.js";
+/**
+ * Orders a search column by how well it matches.
+ *
+ * Most relevant first. Pass it as an `orderBy` value. `find({ search })`
+ * compiles to `matches` plus this, so the SQL is the same.
+ *
+ * @param query - Text to look for
+ * @param options - How to match, and the text search language. Same words as `matches`
+ * @returns A tagged order
+ */
+export declare function relevance(query: string, options?: SearchOptions): Relevance;

package/dist/dialects/pg/ops/search-query.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared operand for `matches` and `relevance`.
+ *
+ * Both helpers store this shape. The SQL compiler reads it once, so `search`
+ * and the two helpers emit the same text.
+ */
+import type { MatchValue, SearchMatch } from "../operators.js";
+/** Options `matches` and `relevance` take. */
+export type SearchOptions = {
+    /** How to match. Omitted means `natural`. */
+    readonly match?: SearchMatch;
+    /** Text search language, such as `english`. Omitted uses the database default. */
+    readonly language?: string;
+};
+/**
+ * Stores the text, the match, and the language.
+ *
+ * @param query - Text to look for
+ * @param options - Match and language. Omitted means natural, database language
+ * @returns The operand both helpers tag
+ */
+export declare function searchValue(query: string, options?: SearchOptions): MatchValue;

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

@@ -0,0 +1,103 @@
+/**
+ * Window helpers for `select` (spec §10, §13 tool 12).
+ *
+ * The brand is a symbol. JSON cannot create one, so a request cannot add a
+ * window. A plain object in `select` stays OKM1120. The SQL loads on the first
+ * `find` or `one` whose `select` contains one.
+ */
+declare const brand: unique symbol;
+/** `asc` is nulls last and `desc` is nulls first unless `nulls` is set. */
+type SortDir = "asc" | "desc" | {
+    readonly dir: "asc" | "desc";
+    readonly nulls?: "first" | "last";
+};
+/** Columns the window orders by. Names are checked when the call runs. */
+export type WindowOrder = {
+    readonly [field: string]: SortDir | undefined;
+};
+/** What a window helper stores. The planner reads this. */
+export type WindowCall = {
+    readonly label: "rowNumber" | "rank" | "denseRank" | "runningTotal";
+    readonly fn: "row_number" | "rank" | "dense_rank" | "sum";
+    readonly column: string | undefined;
+    readonly partitionBy: readonly string[] | undefined;
+    readonly orderBy: unknown;
+    readonly as: string;
+};
+/**
+ * A window helper.
+ *
+ * `A` is the result key. `V` is `number` for a rank, or the source column for
+ * a running total.
+ */
+export type Window<A extends string, V extends string | number> = {
+    readonly [brand]: V;
+    readonly as: A;
+};
+/**
+ * Options every window helper takes.
+ *
+ * `partitionBy` is the group. Omit it to number the whole result. `orderBy`
+ * is the order inside that group. The primary key breaks ties. `as` is the
+ * result key. `__proto__`, `constructor`, `toString`, and `hasOwnProperty`
+ * are refused when the call runs.
+ */
+type WindowOptions<A extends string> = {
+    readonly partitionBy?: readonly string[];
+    readonly orderBy: WindowOrder;
+    readonly as: A;
+};
+/**
+ * Reports whether `value` is a window helper.
+ *
+ * @param value - One `select` entry
+ * @returns `true` when a helper in this module created it
+ */
+export declare function isWindow(value: unknown): value is WindowCall;
+/**
+ * Row number inside a group, starting at 1.
+ *
+ * Ties get distinct numbers. The primary key breaks them.
+ *
+ * @typeParam A - Result key
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function rowNumber<const A extends string>(options: WindowOptions<A>): Window<A, number>;
+/**
+ * Rank inside a group, with gaps after a tie.
+ *
+ * Two rows with the same order share a rank. The next rank skips. The primary
+ * key breaks the order when you need a stable row, and it does not split the
+ * rank.
+ *
+ * @typeParam A - Result key
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function rank<const A extends string>(options: WindowOptions<A>): Window<A, number>;
+/**
+ * Rank inside a group, without gaps after a tie.
+ *
+ * Two rows with the same order share a rank. The next rank is the next number.
+ *
+ * @typeParam A - Result key
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function denseRank<const A extends string>(options: WindowOptions<A>): Window<A, number>;
+/**
+ * Running total of a number column.
+ *
+ * The total follows `orderBy` inside the group. A null number does not add.
+ * The result uses the column's value type: a number, or the exact decimal
+ * string of a `numeric` column.
+ *
+ * @typeParam C - Column
+ * @typeParam A - Result key
+ * @param column - Field to total
+ * @param options - Group, order, and result key
+ * @returns A tagged window. Pass it in `select` on `find` or `one`
+ */
+export declare function runningTotal<const C extends string, const A extends string>(column: C, options: WindowOptions<A>): Window<A, C>;
+export {};

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

@@ -44,7 +44,7 @@ export type Preset<Row> = (q: PresetQuery<Row>, ...args: never[]) => PresetQuery
  * 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";
+export type ReservedPreset = "find" | "one" | "page" | "aggregate" | "count" | "exists" | "insert" | "update" | "delete" | "descendants" | "ancestors" | "sync" | "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.