kern-orm 0.3.0 → 0.5.0

package/dist/{index-CNqYlONX.d.mts → index-Cag6_erK.d.mts}

@@ -209,7 +209,7 @@ interface SqlStatement {
 declare function createStatement(text: string, parameters?: readonly TextValue[]): SqlStatement;
 /** Result of a statement. */
 interface DriverResult {
-  /** Command tag that PostgreSQL completed the statement with, such as `SELECT` or `ROLLBACK` for a `COMMIT` of a failed transaction. */
+  /** Command of the tag that PostgreSQL completed the statement with, such as `SELECT` or `ROLLBACK` for a `COMMIT` of a failed transaction; a driver may give only the first word of a tag of several words, such as `CREATE` of `CREATE TABLE`. */
   readonly command: string;
   /** Number of rows that the command tag reports, such as the rows that an `UPDATE` changes, also without `RETURNING`; `0` for a command without one, such as `BEGIN`. */
   readonly count: number;
@@ -273,6 +273,11 @@ interface NestedField {
   readonly key: string;
   readonly nested: ResultPlan;
 }
+/** Field of a record in the template of a result plan: its key and its value before the values of a row are assigned. */
+interface RecordTemplateField {
+  readonly key: string;
+  readonly value: unknown;
+}
 /**
  * How a query returns its rows: `many` as an array; `one` as one row, rejecting without it; `nullable` as one row or `null` without it; `optional` as one row or `undefined` without it.
  *
@@ -292,6 +297,12 @@ interface ResultPlan extends ResultMode {
   readonly fields: readonly ResultField[];
   /** Required relation that guarantees the row of nested rows `one`, such as `field.form`, whose missing row is a `RequiredRelationError` rather than a `NotFoundError`. */
   readonly guaranteedBy?: string | undefined;
+  /**
+   * Every field of a record in its order, with the values of its literals, which a row does not hold; `undefined` for a query without literals.
+   *
+   * A record starts from it, so its keys keep their order whichever of them a row holds.
+   */
+  readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
 }
 /** Error thrown when a query of one row finds no row, executed or nested, unless a required relation guarantees the row. */
 declare class NotFoundError extends Error {
@@ -474,6 +485,87 @@ interface ComparisonSignature extends OperatorSignature {
  * Operators of custom types build comparisons with it, such as `compare(self, "ILIKE", pattern)`.
  */
 declare function compare<T, V>(self: AnyExpression<T>, operator: ComparisonNode["operator"], value: V): Expression<BooleanResult<T | OperandValue<V>>>;
+/** Runtime mark of the operators of `equalityOperators`, which tell that a type has SQL `=`. */
+declare const equalityBrand: unique symbol;
+/** Generic operator of `equalityOperators`, which gives the type it is added to SQL `=`. */
+interface EqualityOperator<S extends OperatorSignature> extends GenericOperator<S> {
+  readonly [equalityBrand]: true;
+}
+/** Key of the method of a query of a table that returns its node as the values of `in`, or rejects a query of records. */
+declare const valuesQueryNode: unique symbol;
+/** Signature of `in`: membership in a list of operands of the expression type, or in the values of a query, such as of `pluck`; an empty list or query yields `FALSE`. */
+interface InSignature extends OperatorSignature {
+  readonly method: <const L extends readonly Operand<this["T"], this["I"]>[] | ValuesQuery<NonNullable<this["T"]> | null>>(list: L) => Expression<L extends readonly unknown[] ? L extends readonly [] ? boolean : BooleanResult<this["T"] | OperandValue<L[number]>> : BooleanResult<this["T"] | (L extends ValuesQuery ? ValuesQueryValue<L> : never)>>;
+}
+/** Operators of `equalityOperators`. */
+type EqualityOperators = {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
+};
+/** Tells whether operators `O` include an operator of `equalityOperators`, so that their type has SQL `=`. */
+type HasEquality<O> = true extends { [K in keyof O]: O[K] extends {
+  readonly [equalityBrand]: true;
+} ? true : false; }[keyof O] ? true : false;
+/**
+ * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+ *
+ * A type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
+ */
+declare const equalityOperators: EqualityOperators;
+/** Records of a query without selected fields. */
+type EmptyRecord = Record<never, never>;
+/** State of a query in types: the record or value of its rows, how its rows become its result, and the relations it selects records of. */
+interface QueryState extends ResultMode {
+  /** Record of a row, or the value of its only field for a query made by `get`, `pluck`, an aggregate method, such as `count`, or `exists`. */
+  readonly result: unknown;
+  /** Relations whose records the query and the queries nested in it select, which a `Db` must have. */
+  readonly uses: UsedRelation;
+}
+/** Type of the value of a query: the values that it encodes, such as the fallback of `coalesce`, and its operators, which `expr` gives its expression. */
+interface QueryValueType {
+  readonly input: unknown;
+  readonly operators: OperatorDefinitions;
+}
+/**
+ * State of a select query in types: its table, the relations of its schema, the record or value of its rows and the type of its value, how its rows become its result, and the relations it selects records of.
+ *
+ * Methods change only their own parts of the state.
+ */
+interface SelectQueryState extends QueryState {
+  readonly table: AnyTable;
+  readonly schema: SchemaContext;
+  /** Type of the value of a query of values, a `QueryValueType`; `never` for a query of records. */
+  readonly valueType: unknown;
+  /**
+   * Whether a required relation guarantees the row of the query, such as of `field.form`.
+   *
+   * The relation does not guarantee a record that also passes a filter, so `where`, `find`, and `findBy` end the guarantee and make rows `one` `nullable`, or `optional` for a query of values; `optional`, `nullable`, and `required` end it as well.
+   * The callback of a helper starts with it, so that the effect of the helper records whether the callback filters.
+   */
+  readonly guaranteed: boolean;
+  /** Whether the query is made by an aggregate method, such as `count`, or by `exists`, which makes `get`, `pluck`, the aggregate methods, and `exists` reject it. */
+  readonly aggregate: boolean;
+}
+/** State of a query over table `T` with schema context `C`, whatever its result. */
+interface QueryStateOf<T extends AnyTable, C extends SchemaContext = SchemaContext> extends SelectQueryState {
+  readonly table: T;
+  readonly schema: C;
+}
+/**
+ * State of a query that starts from table `T` with schema context `C`: rows as records without fields, all of them or of the records of relation `U` when given, in rows mode `Rows`, guaranteed by a required relation when `Guaranteed`.
+ *
+ * Without relations in `C`, it also types a query of the table in a schema that has relations of the table.
+ */
+interface InitialQueryState<T extends AnyTable, C extends SchemaContext = NoRelations, U extends UsedRelation = never, Rows extends ResultRows = "many", Guaranteed extends boolean = false> extends QueryStateOf<T, C> {
+  readonly result: EmptyRecord;
+  readonly valueType: never;
+  readonly rows: Rows;
+  readonly value: false;
+  readonly uses: U;
+  readonly guaranteed: Guaranteed;
+  readonly aggregate: false;
+}
 /** Selection of the rows of a nested query as the value of the field `key`. */
 interface NestedSelectionNode {
   readonly key: string;
@@ -481,8 +573,15 @@ interface NestedSelectionNode {
   /** `Db` that the nested query is bound to, which must be the `Db` that runs the statement. */
   readonly db: AnyDb | undefined;
 }
-/** Field selected by a query: an expression, or the rows of a nested query. */
-type SelectedNode = ProjectionNode | NestedSelectionNode;
+/** Selection of a value from code as the field `key` of every record, which a statement does not select. */
+interface LiteralSelectionNode {
+  readonly key: string;
+  readonly literal: unknown;
+}
+/** Field that a statement selects: an expression, or the rows of a nested query. */
+type SqlSelectedNode = ProjectionNode | NestedSelectionNode;
+/** Field selected by a query: one that its statement selects, or a literal. */
+type SelectedNode = SqlSelectedNode | LiteralSelectionNode;
 /** Select query of a table; its result mode applies when it is executed or its rows are nested. */
 interface QueryNode extends ResultMode {
   readonly kind: "query";
@@ -506,102 +605,344 @@ interface QueryNode extends ResultMode {
  * Its result mode is the rows mode of the rows it changes and whether a row is the value of its only field.
  */
 type MutationNode = MutationStatementNode<SelectedNode>;
-/** Query of `$select` without a source: one record whose fields are the values of expressions and the rows of independent queries. */
+/** Query of `$select` without a source: one record whose fields are the values of expressions, the rows of independent queries, and literals. */
 interface RecordQueryNode {
   readonly kind: "record";
   /** Fields in the order of the record, with unique keys. */
   readonly projections: readonly SelectedNode[];
 }
-/** Records of a query without selected fields. */
-type EmptyRecord = Record<never, never>;
-/** State of a query in types: the record or value of its rows, how its rows become its result, and the relations it selects records of. */
-interface QueryState extends ResultMode {
-  /** Record of a row, or the value of its only field for a query made by `get`, `pluck`, an aggregate method, such as `count`, or `exists`. */
-  readonly result: unknown;
-  /** Relations whose records the query and the queries nested in it select, which a `Db` must have. */
-  readonly uses: UsedRelation;
+/**
+ * Field of a selection whose value is `T`, made by `literal`.
+ *
+ * It is not an expression: it has no SQL, so only a selection takes it.
+ */
+declare class Literal<out T> {
+  /** Value of the field in every record, which the query returns as it is. */
+  readonly literal: T;
+  constructor(
+  /** Value of the field in every record, which the query returns as it is. */
+  literal: T);
+  /** Rejects the literal as an operand of an expression: a statement has no SQL of it. */
+  [operandNode](): never;
+}
+/**
+ * Creates a field of a selection with `value` in every record, without selecting anything in SQL: the query returns the value itself, not a copy of it, whatever it is.
+ *
+ * It lets a branch of a selection skip a column or a nested query, such as `withHint ? field.hint : literal(null)`.
+ * To use a value in SQL, such as in a condition, pass it through `param` instead.
+ */
+declare function literal<T extends {} | null | undefined>(value: T): Literal<T>;
+/** Rows mode of a query of a relation of kind `Kind`: `many`, or one row, `nullable` unless `Required` is `true`; a union gives the union of their modes. */
+type RelationRows<Kind extends RelationKind, Required extends boolean> = Kind extends "many" ? "many" : Required extends true ? "one" : "nullable";
+/** Rows mode after a filter of a query whose row a required relation guarantees: `one` becomes `nullable`, or `optional` for a query of values; other modes stay. */
+type FilteredRows<Rows extends ResultRows, Value extends boolean> = Rows extends "one" ? Value extends true ? "optional" : "nullable" : Rows;
+/** Rows mode after `take`: `many` becomes `one`; the modes of one row stay. */
+type OneRow<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows;
+/** Rows mode after `pluck`: `nullable` becomes `optional`; the other modes stay. */
+type ValueRows<Rows extends ResultRows> = Rows extends "nullable" ? "optional" : Rows;
+/** Rows mode after `get`: `many` becomes `one` and `nullable` becomes `optional`; `one` and `optional` stay. */
+type OneValueRows<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows extends "nullable" ? "optional" : Rows;
+/**
+ * Result of a query of state `S`, executed or nested: an array of records or values, or one of them, `null` or `undefined` when a query of rows `nullable` or `optional` finds no row.
+ *
+ * It is the union of the results of every state that `S` allows, such as of a union of rows modes.
+ */
+type QueryResult<S extends QueryState> = S extends QueryState ? ResultByRows<S["result"], S["rows"]> : never;
+/** Result of rows of `Result` returned in rows mode `Rows`; a union of modes gives the union of their results. */
+type ResultByRows<Result, Rows extends ResultRows> = Rows extends "many" ? Result[] : Rows extends "one" ? Result : Rows extends "nullable" ? Result | null : Result | undefined;
+/** Expressions, nested queries, and literals selected under the keys of the result fields; a record has no symbol keys. */
+interface Selection {
+  readonly [key: string]: TypedExpression | NestedQuery | Literal<unknown>;
+  readonly [key: symbol]: never;
+}
+/** Query whose rows a selection nests as the value of a field: a query of any state and kind, such as a query of a relation. */
+type NestedQuery = QueryOf<SelectQueryState>;
+/** Record of the values of the expressions, of the nested rows, and of the literals of a selection. */
+type SelectionResult<S extends Selection> = { [K in keyof S]: FieldValue<S[K]>; };
+/** Value of a selected field: of an expression, of the nested rows of a query as the result of executing it, or of a literal, for each member of a union of them. */
+type FieldValue<V> = V extends NestedQuery ? QueryResult<V["types"]> : V extends Literal<infer T> ? T : ExpressionValue<V>;
+/** Relations whose records the nested queries of a selection select. */
+type SelectionUses<S extends Selection> = S[keyof S] extends (infer V) ? V extends NestedQuery ? V["types"]["uses"] : never : never;
+/** Value of a selected expression. */
+type ExpressionValue<E> = E extends AnyExpression<infer T> ? T : never;
+/** Values that the type of an expression encodes, such as in place of its value. */
+type ExpressionInput<E> = E extends AnyExpression<unknown, infer I> ? I : never;
+declare const helperFields: unique symbol;
+/** Marker of the input fields of a helper, carrying the keys selected by its callback. */
+interface HelperFields<Keys extends PropertyKey = PropertyKey> {
+  readonly [helperFields]: Keys;
+}
+/** Records with `Fields` added or replaced, for each branch of either record type; `any` stays `any`. */
+type MergeSelection<Previous, Fields> = Previous extends unknown ? Fields extends unknown ? MergeFields<RecordFields<Previous>, RecordFields<Fields>> & (IsAny<Previous> extends true ? Previous : unknown) : never : never;
+/** Fields with numeric keys represented as the string keys used in result records. */
+type RecordFields<Fields> = Fields extends unknown ? [Extract<keyof Fields, number>] extends [never] ? Fields : { [K in keyof Fields as K extends number ? `${K}` : K]: Fields[K]; } : never;
+/** Merge of normalized fields, retaining the previous value when an optional replacement is absent. */
+type MergeFields<Previous, Fields> = Simplify<{ [K in keyof Previous as K extends keyof Fields ? ({} extends Pick<Fields, K> ? K : never) : K]: K extends typeof helperFields // A branch selecting extra keys must not be reduced to one selecting fewer fields or none.
+ ? Previous[K] | keyof Fields : K extends keyof Fields // A decoder can return undefined, so it cannot be excluded as merely an absent property.
+ ? Previous[K] | Fields[K] : Previous[K]; } & { [K in keyof Fields as K extends keyof Previous ? ({} extends Pick<Fields, K> ? never : K) : K]: Fields[K]; }>;
+/** State of a query of `$select` in types: one record `R`, whose nested queries select records of relations `U`. */
+interface RecordQueryState$1<R = unknown, U extends UsedRelation = UsedRelation> extends QueryState {
+  readonly result: R;
+  readonly rows: "one";
+  readonly value: false;
+  readonly uses: U;
+}
+/** State of the query of `$select` of `Sel`: the record of the values of its expressions and of its literals and the results of its queries. */
+type SelectionState<Sel extends Selection> = RecordQueryState$1<MergeSelection<EmptyRecord, SelectionResult<Sel>>, SelectionUses<Sel>>;
+/**
+ * Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and of literals and the results of independent queries, selected in one statement.
+ *
+ * An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
+ * A bound query executes on its `Db` when awaited.
+ */
+declare class RecordQuery<out S extends RecordQueryState$1, out Kind extends SelectQueryKind = "unbound"> {
+  readonly node: RecordQueryNode;
+  readonly types: S;
+  /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+  readonly db: QueryDb<Kind>;
+  /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+  readonly then: QueryThen<S, Kind>;
+  constructor(node: RecordQueryNode, db?: AnyDb);
+  /**
+   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
+   *
+   * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
+   */
+  toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+  [operandNode](): never;
+}
+/** Query of `$select` of any state and kind. */
+type AnyRecordQuery = RecordQuery<any, SelectQueryKind>;
+declare const schemaBrand: unique symbol;
+/** Key of the relation definitions of a schema, which composition reads. */
+declare const schemaRelations: unique symbol;
+/** Tables by their keys; a key must not start with `$`, which is reserved for schema and `Db` members. */
+type Tables = Record<string, AnyTable>;
+/**
+ * Immutable collection of tables and their relations with query entry points.
+ *
+ * A schema is not bound to a database, so queries built from it can be defined at module level.
+ * A `Db` can execute such a query if its schema contains the tables and the selected relations of the query and every bound nested query belongs to that `Db`.
+ */
+type Schema<T extends Tables, R extends SchemaRelations = EmptyRecord> = SchemaEntries<T, R> & SchemaMembers<T, R>;
+/** Query entry points; each access starts a query over a new table occurrence. */
+type SchemaEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: SelectQuery<InitialQueryState<T[K], TableContext<R, K>>>; };
+/** Members of a schema that composition reads: its tables and the relations of its tables. */
+interface SchemaContents<T extends Tables, R extends SchemaRelations> {
+  readonly [schemaBrand]: true;
+  /** Tables of the schema by their keys. */
+  readonly $tables: T;
+  /** Relation definitions by table key and relation name. */
+  readonly [schemaRelations]: R;
+}
+interface SchemaMembers<T extends Tables, R extends SchemaRelations> extends SchemaContents<T, R> {
+  /**
+   * Creates a schema of the same tables with the relations of `relations` added, declared with `many` and `one` by their names under the keys of their tables.
+   *
+   * A relation refers to a table of the schema by columns of SQL types that `=` compares; a relation that the schema already has is rejected.
+   */
+  $relations<S extends AnySchema, D extends RelationDeclarations<S["$tables"]>>(this: S, relations: D & CheckDeclarations<S["$tables"], D>): Schema<S["$tables"], MergeRelations<S[typeof schemaRelations] & DeclaredRelations<S["$tables"], D>>>;
+  /**
+   * Starts an unbound query of one record whose fields are the values of the expressions and of the literals and the results of the queries of `selection`, selected in one statement.
+   *
+   * The value of the field of a query is the result it gives when executed, such as an array of records or one value.
+   */
+  $select<Sel extends Selection>(selection: Sel): RecordQuery<SelectionState<Sel>>;
+}
+/** Schema of any tables and relations. */
+type AnySchema = SchemaContents<Tables, SchemaRelations>;
+/** Part of a schema definition: an object of tables by their keys, or a schema whose tables and relations it includes. */
+type SchemaPart = Tables | AnySchema;
+/**
+ * Tables of the parts of a schema definition by their keys.
+ *
+ * A part typed as a union gives a union of tables, and parts of an array of unknown length give no tables, since any of them may be missing.
+ */
+type SchemaTables<P extends readonly SchemaPart[]> = ComposeParts<P>["tables"] extends (infer T extends Tables) ? { [K in keyof T]: T[K]; } : never;
+/** Relations of the parts of a schema definition by table key and relation name, read as `SchemaTables` reads the tables. */
+type SchemaPartRelations<P extends readonly SchemaPart[]> = ComposeParts<P>["relations"] extends (infer R extends SchemaRelations) ? MergeRelations<R> : never;
+/** Tables and relations of the parts of a schema definition, intersected. */
+interface PartContents {
+  readonly tables: Tables;
+  readonly relations: SchemaRelations;
+}
+type ComposeParts<P extends readonly SchemaPart[], Composed extends PartContents = {
+  tables: EmptyRecord;
+  relations: EmptyRecord;
+}> = P extends readonly [infer First extends SchemaPart, ...infer Rest extends readonly SchemaPart[]] ? ComposeParts<Rest, Composed & ReadPart<First>> : P extends readonly [...infer Rest extends readonly SchemaPart[], infer Last extends SchemaPart] ? ComposeParts<Rest, Composed & ReadPart<Last>> : Composed;
+type ReadPart<P extends SchemaPart> = P extends SchemaContents<infer T, any> ? {
+  tables: T;
+  relations: P[typeof schemaRelations];
+} : {
+  tables: P;
+  relations: EmptyRecord;
+};
+/**
+ * Defines a schema of the tables of `parts`, keyed by their names in queries.
+ *
+ * A part is an object of tables by their keys or another schema, whose tables and relations the new schema includes as they are, so queries built from that schema run on the new one.
+ * A key of two different tables, a table under two keys, and two different definitions of a relation of a table are rejected; the same table under the same key or the same relation in several parts is one.
+ */
+declare function defineSchema<P extends SchemaPart[]>(...parts: P): Schema<SchemaTables<P>, SchemaPartRelations<P>>;
+declare const sourceTable: unique symbol;
+declare const sourceKey: unique symbol;
+/** Runtime mark of the declarations of `many` and `one`. */
+declare const declarationBrand: unique symbol;
+/** Kind of a relation: `many` related records, or `one` related record at most. */
+type RelationKind = "many" | "one";
+/** Relation of a table of a schema to the records of table `Target`, which has key `TargetKey` in the schema. */
+interface Relation<Kind extends RelationKind = RelationKind, Target extends AnyTable = AnyTable, TargetKey extends string = string, Required extends boolean = boolean> {
+  readonly kind: Kind;
+  readonly target: Target;
+  readonly targetKey: TargetKey;
+  /** Whether every record of the table has its related record, so that a query of a relation `one` without a filter rejects without it rather than giving `null`; `false` for a relation `many`. */
+  readonly required: Required;
+}
+/**
+ * Relation of a table of a schema as `$relations` defines it: the columns of its keys, compared by SQL `=` in order.
+ *
+ * Composition includes a definition as it is, so a relation that several parts include is one definition.
+ */
+interface RelationDefinition extends Relation {
+  readonly name: string;
+  /** Key of the source table. */
+  readonly key: string;
+  readonly source: AnyTable;
+  readonly from: readonly string[];
+  readonly to: readonly string[];
+}
+/** Relation `N` of the table under key `K` of a schema, of type `R`, whose records a query selects. */
+interface UsedRelation<K extends string = string, N extends string = string, R extends Relation = Relation> {
+  readonly key: K;
+  readonly name: N;
+  readonly relation: R;
+}
+/** Relations of schema relations `R` that the queries of a `Db` of the schema may select. */
+type UsableRelation<R extends SchemaRelations> = { [K in keyof R & string]: { [N in keyof R[K] & string]: UsedRelation<K, N, R[K][N]>; }[keyof R[K] & string]; }[keyof R & string];
+/** Relations of the tables of a schema by table key and relation name. */
+type SchemaRelations = {
+  readonly [key: string]: TableRelations;
+};
+/** Relations of a table of a schema by relation name. */
+type TableRelations = {
+  readonly [name: string]: Relation;
+};
+/**
+ * Declaration of a relation by `many` or `one`, which `$relations` of a schema defines for a table of type `Source` with key `From` of the source table.
+ *
+ * `Source` and `From` only type the keys of the source table.
+ */
+interface RelationDeclaration<Kind extends RelationKind, Source extends AnyTable, Target extends AnyTable, From = unknown, Required extends boolean = boolean> {
+  readonly [declarationBrand]: true;
+  readonly kind: Kind;
+  readonly target: Target;
+  readonly from: readonly string[];
+  readonly to: readonly string[];
+  readonly required: Required;
+  readonly [sourceTable]?: (source: Source) => void;
+  readonly [sourceKey]?: From;
+}
+/** Column key of table `T` whose type has SQL `=`, which a relation can compare. */
+type EqualityKey<T extends AnyTable> = { [K in keyof T["columns"]]: HasEquality<ColumnOperators<T, K>> extends true ? K : never; }[keyof T["columns"]] & string;
+/** Key of a relation in table `T`: a column key, or a non-empty list of them for a composite key. */
+type RelationKey<T extends AnyTable> = EqualityKey<T> | readonly [EqualityKey<T>, ...EqualityKey<T>[]];
+/** Key of table `T` with as many columns as key `From`. */
+type MatchingKey<T extends AnyTable, From> = From extends string ? EqualityKey<T> : { readonly [I in keyof From]: EqualityKey<T>; };
+/** Keys of a relation: the columns `from` of the source table equal the columns `to` of the target table, in order. */
+interface RelationKeys<Target extends AnyTable, From> {
+  readonly from: From;
+  readonly to: MatchingKey<Target, From>;
+}
+/** Keys of a relation `one`, as in `RelationKeys`, and whether the relation is required. */
+interface OneRelationKeys<From, To> {
+  readonly from: From;
+  readonly to: To;
+  /** Whether every record has its related record, such as by a foreign key on columns `from` that are not nullable, so that a query of the relation without a filter rejects without it rather than giving `null`. */
+  readonly required?: boolean;
+}
+/** Members of the keys `K` of a relation `one` with only `required` typed, so that a call infers `K` with `required` as optional as it is, and reports a wrong key at its own member. */
+type RequiredMember<K> = { readonly [P in keyof K]: P extends "required" ? K[P] : unknown; };
+/** Whether the keys `K` of a relation `one` make it required: only where they set `required` to `true`, and `boolean` where `required` may be `true` or missing, such as `required?: true`. */
+type DeclaredRequiredOf<K> = K extends unknown ? "required" extends keyof K ? K extends {
+  readonly required: infer Required;
+} ? IsTrue<Required> : IsTrue<K["required" & keyof K] | undefined> : false : never;
+/** `true` for `true`, and `false` for other values, such as `false` and `undefined`; a union gives the union of their results. */
+type IsTrue<T> = T extends true ? true : false;
+/** Declarations of `$relations` of a schema of tables `T`: relations by name, for tables by their keys. */
+type RelationDeclarations<T extends Tables> = { readonly [K in keyof T]?: {
+  readonly [name: string]: RelationDeclaration<RelationKind, T[K], T[keyof T]>;
+}; };
+/**
+ * Declarations `D` of `$relations` checked by the names they use: relations of the tables of `T` under their keys, and no other keys.
+ *
+ * Declarations under the names of `D` get their source table from this type even where the index signature of `RelationDeclarations` gives way to a member of `Object`, such as for a relation named `toString`.
+ * A relation name must not be a column key of its table or start with `$`, since the references that the callback of `select` gets have both.
+ */
+type CheckDeclarations<T extends Tables, D> = { readonly [K in keyof D]: [TableKey<T, K>] extends [never] ? never : undefined extends D[K] ? D[K] : { readonly [N in keyof D[K]]: `${N & (string | number)}` extends ReservedName<T[TableKey<T, K>]> ? never : RelationDeclaration<RelationKind, T[TableKey<T, K>], T[keyof T], RelationKey<T[TableKey<T, K>]>>; }; };
+/** Names that a relation of table `T` cannot have: the keys of its columns, and names starting with `$`. */
+type ReservedName<T extends AnyTable> = `${keyof T["columns"] & (string | number)}` | `$${string}`;
+/** Key of tables `T` written as key `K`, such as `1` for `"1"`, as object keys are strings at runtime. */
+type TableKey<T extends Tables, K> = { [P in keyof T]: `${P & (string | number)}` extends `${K & (string | number)}` ? P : never; }[keyof T];
+/** Relations that declarations `D` of a schema of tables `T` define, by table key and relation name, as strings like the keys of objects. */
+type DeclaredRelations<T extends Tables, D> = { [K in keyof D as K extends number ? `${K}` : K]: { [N in keyof D[K] as N extends number ? `${N}` : N]: D[K][N] extends RelationDeclaration<infer Kind, never, infer Target, unknown, infer Required> ? Relation<Kind, Target, KeyOfTable<T, Target>, Required> : never; }; };
+/** Column key of relation key `K`: the key itself, or a column of a composite key. */
+type RelationColumn<K> = K extends readonly unknown[] ? K[number] : K;
+/** Check of key `To` of a relation `one` that rejects it when its columns include no key of table `Target`, as far as the types tell. */
+type TargetKeyCheck<Target extends AnyTable, To> = [ContainsKey<Target, RelationColumn<To>>] extends [false] ? {
+  readonly to: MissingKey<KeyOf<Target["keys"]>>;
+} : unknown;
+/** Type that a key `to` of a relation `one` without a key of its target is checked against, naming the keys of the target. */
+interface MissingKey<Keys> {
+  readonly "columns to must include a key of the target": Keys;
 }
-/** Type of the value of a query: the values that it encodes, such as the fallback of `coalesce`, and its operators, which `expr` gives its expression. */
-interface QueryValueType {
-  readonly input: unknown;
-  readonly operators: OperatorDefinitions;
+/** Key of table `Target` among tables `T`, as a string like the keys of objects. */
+type KeyOfTable<T extends Tables, Target> = { [K in keyof T]: [T[K]] extends [Target] ? [Target] extends [T[K]] ? K extends number ? `${K}` : K & string : never : never; }[keyof T];
+/** Relations of `R` by table key, with the relations under the same key merged. */
+type MergeRelations<R> = { [K in keyof R]: { [N in keyof R[K]]: R[K][N]; }; };
+/** Relations of the schema that a query starts from, by table key, and the key of the table of the query there. */
+interface SchemaContext<R extends SchemaRelations = SchemaRelations, K extends string = string> {
+  readonly relations: R;
+  readonly key: K;
 }
+/** Schema context of a query whose table has no relations, such as one of `from(table)`. */
+type NoRelations = SchemaContext<EmptyRecord, string>;
+/** Schema context of the queries of the table under key `K` of a schema of relations `R`, whose keys are strings, as object keys are at runtime. */
+type TableContext<R extends SchemaRelations, K> = K extends keyof R ? [keyof R[K]] extends [never] ? NoRelations : SchemaContext<R, K & string> : K extends number ? TableContext<R, `${K}`> : NoRelations;
 /**
- * State of a select query in types: its table, the relations of its schema, the record or value of its rows and the type of its value, how its rows become its result, and the relations it selects records of.
+ * Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
  *
- * Methods change only their own parts of the state.
+ * A composite key lists its columns in arrays of the same length.
  */
-interface SelectQueryState extends QueryState {
-  readonly table: AnyTable;
-  readonly schema: SchemaContext;
-  /** Type of the value of a query of values, a `QueryValueType`; `never` for a query of records. */
-  readonly valueType: unknown;
-  /**
-   * Whether a required relation guarantees the row of the query, such as of `field.form`.
-   *
-   * The relation does not guarantee a record that also passes a filter, so `where`, `find`, and `findBy` end the guarantee and make rows `one` `nullable`, or `optional` for a query of values; `optional`, `nullable`, and `required` end it as well.
-   * The callback of a helper starts with it, so that the effect of the helper records whether the callback filters.
-   */
-  readonly guaranteed: boolean;
-  /** Whether the query is made by an aggregate method, such as `count`, or by `exists`, which makes `get`, `pluck`, the aggregate methods, and `exists` reject it. */
-  readonly aggregate: boolean;
-}
-/** State of a query over table `T` with schema context `C`, whatever its result. */
-interface QueryStateOf<T extends AnyTable, C extends SchemaContext = SchemaContext> extends SelectQueryState {
-  readonly table: T;
-  readonly schema: C;
-}
+declare function many<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>>(target: Target, keys: RelationKeys<Target, From>): RelationDeclaration<"many", Source, Target, From, false>;
 /**
- * State of a query that starts from table `T` with schema context `C`: rows as records without fields, all of them or of the records of relation `U` when given, in rows mode `Rows`, guaranteed by a required relation when `Guaranteed`.
+ * Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
  *
- * Without relations in `C`, it also types a query of the table in a schema that has relations of the table.
+ * A composite key lists its columns in arrays of the same length.
+ * The columns `to` must include a key of `target`, primary or unique, so that they match at most one record.
+ * Without the record, a query of the relation gives `null`, and a query of a relation declared with `required: true` rejects unless it filters the record.
+ * Set `required: true` only where the database guarantees the record, such as by a foreign key on columns `from` that are not nullable.
  */
-interface InitialQueryState<T extends AnyTable, C extends SchemaContext = NoRelations, U extends UsedRelation = never, Rows extends ResultRows = "many", Guaranteed extends boolean = false> extends QueryStateOf<T, C> {
-  readonly result: EmptyRecord;
-  readonly valueType: never;
-  readonly rows: Rows;
-  readonly value: false;
-  readonly uses: U;
-  readonly guaranteed: Guaranteed;
-  readonly aggregate: false;
-}
+declare function one<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>, const To extends MatchingKey<Target, From>, const Keys extends object = EmptyRecord>(target: Target, keys: OneRelationKeys<From, To> & RequiredMember<Keys> & TargetKeyCheck<Target, To>): RelationDeclaration<"one", Source, Target, From, NoInfer<DeclaredRequiredOf<Keys>>>;
 /** Type of a count: a `bigint` of PostgreSQL decoded as a number, rejecting a count that a number cannot hold exactly. */
 declare const countType: BaseType<number, number, MergeOperators<NoOperators, {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 }>, undefined>;
 /** Type of the value of a query of a count. */
 interface CountValueType extends QueryValueType {
   readonly input: TypeInput<typeof countType>;
   readonly operators: TypeOperators<typeof countType>;
 }
-/** Rows mode of a query of a relation of kind `Kind`: `many`, or one row, `nullable` unless `Required` is `true`; a union gives the union of their modes. */
-type RelationRows<Kind extends RelationKind, Required extends boolean> = Kind extends "many" ? "many" : Required extends true ? "one" : "nullable";
-/** Rows mode after a filter of a query whose row a required relation guarantees: `one` becomes `nullable`, or `optional` for a query of values; other modes stay. */
-type FilteredRows<Rows extends ResultRows, Value extends boolean> = Rows extends "one" ? Value extends true ? "optional" : "nullable" : Rows;
-/** Rows mode after `take`: `many` becomes `one`; the modes of one row stay. */
-type OneRow<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows;
-/** Rows mode after `pluck`: `nullable` becomes `optional`; the other modes stay. */
-type ValueRows<Rows extends ResultRows> = Rows extends "nullable" ? "optional" : Rows;
-/** Rows mode after `get`: `many` becomes `one` and `nullable` becomes `optional`; `one` and `optional` stay. */
-type OneValueRows<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows extends "nullable" ? "optional" : Rows;
-/**
- * Result of a query of state `S`, executed or nested: an array of records or values, or one of them, `null` or `undefined` when a query of rows `nullable` or `optional` finds no row.
- *
- * It is the union of the results of every state that `S` allows, such as of a union of rows modes.
- */
-type QueryResult<S extends QueryState> = S extends QueryState ? ResultByRows<S["result"], S["rows"]> : never;
-/** Result of rows of `Result` returned in rows mode `Rows`; a union of modes gives the union of their results. */
-type ResultByRows<Result, Rows extends ResultRows> = Rows extends "many" ? Result[] : Rows extends "one" ? Result : Rows extends "nullable" ? Result | null : Result | undefined;
 /** References to the columns of the query source, passed to query callbacks. */
 type ColumnRefs<T extends AnyTable> = { readonly [K in keyof T["columns"]]: Expression<Selectable<T>[K], ColumnOperators<T, K>, ColumnValues<T>[K]>; };
 /**
- * Queries of the records of the relations of the table of schema context `C`, by relation name, which the callbacks of `select`, `where`, and `orderBy` receive beside the columns.
+ * Queries of the records of the relations of the table of schema context `C`, by relation name, which the callbacks of queries receive beside the columns.
  *
  * A relation name is never a column key of its table.
  * A context whose table key is not known, such as one of a query of any schema, has no relations.
@@ -612,7 +953,7 @@ type RelationQueries<R extends SchemaContext["relations"], K extends keyof R & s
 type RelatedQuery<R extends SchemaContext["relations"], K extends keyof R & string, N extends keyof R[K] & string> = SelectQuery<InitialQueryState<R[K][N]["target"], TableContext<R, R[K][N]["targetKey"]>, UsedRelation<K, N, R[K][N]>, RelationRows<R[K][N]["kind"], R[K][N]["required"]>, R[K][N]["required"]>>;
 /** Runtime context of the queries of a table in the schema they start from. */
 interface QueryContext {
-  /** Getters of the queries of the relations of the table, which the references of the callbacks of `select`, `where`, and `orderBy` have as their own properties and which read the key columns from them. */
+  /** Getters of the queries of the relations of the table, which the references of the callbacks of queries have as their own properties and which read the key columns from them. */
   readonly relations: PropertyDescriptorMap;
 }
 /** Type of the value of a query of `exists`. */
@@ -668,20 +1009,12 @@ type WhereCallback<T extends AnyTable, C extends SchemaContext = NoRelations> =
 /** Argument of `where` of a query over table `T` with schema context `C`: a condition, or a callback that receives the columns and the relations of the query and returns one. */
 type WhereFilter<T extends AnyTable, C extends SchemaContext = NoRelations> = WhereCondition<T> | WhereCallback<T, C>;
 /**
- * Defines a reusable condition of `where` for queries over a table, checking its objects of column values against the columns.
- *
- * The condition can be combined further with `and`, `or`, and `not`.
- */
-declare function defineFilter<T extends AnyTable, C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, filter: NoInfer<WhereCondition<T>>): WhereCondition<T>;
-/**
- * Defines a reusable callback of `where` for queries over a table, checking its objects of column values against the columns.
+ * Argument of `where` of a query of state `S`: a `WhereFilter` of its table and schema, which TypeScript resolves with what it has inferred for `S` before it checks a callback in it.
  *
- * Defined with a query of a schema or a `Db`, such as `schema.form`, it receives the queries of the relations of the table in that schema, and applies to queries whose schema has them.
- * Another callback of `where` can call it with the columns and the relations it receives.
+ * TypeScript types the body of a callback once, for every overload, and a plain `WhereFilter` leaves `S` unresolved there, so the body would widen a literal, such as of an enum column, to `string`.
+ * It reads the filter only in its branch: a general alias that takes the filter as an argument resolves it on every call, which takes about 25 more instantiations.
  */
-declare function defineFilter<T extends AnyTable, C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, filter: NoInfer<WhereCallback<T, C>>): WhereCallback<T, C>;
-/** Defines a reusable filter of `where` for queries over a table, either a condition or a callback. */
-declare function defineFilter<T extends AnyTable, C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, filter: NoInfer<WhereFilter<T, C>>): WhereFilter<T, C>;
+type QueryWhereFilter<S extends SelectQueryState> = [S] extends [unknown] ? WhereFilter<S["table"], S["schema"]> : never;
 /**
  * Values of the primary key of table `T` that `find` takes, in the order of its columns, or `never` where the type of `T` tells no primary key.
  *
@@ -718,7 +1051,7 @@ type OrderTerm = AnyExpression | ScalarQuery | Ordering;
 /**
  * References of the callback of `orderBy` to the fields of records `R` selected by a query: their expressions by key.
  *
- * A field of nested rows is among them in types, but reading it throws; a field of an aggregate or of `exists` sorts by its value.
+ * A field of nested rows or of a literal is among them in types, but reading it throws; a field of an aggregate or of `exists` sorts by its value.
  */
 type SelectedRefs<R> = { readonly [K in keyof R & string]: AnyExpression<R[K]>; };
 /** Sort keys returned by the callback of `orderBy`: one or an array of them. */
@@ -729,46 +1062,20 @@ declare function asc(value: AnyExpression | ScalarQuery): Ordering;
 declare function desc(value: AnyExpression | ScalarQuery): Ordering;
 /** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
 declare function orderBy(value: AnyExpression | ScalarQuery, direction: OrderDirection): Ordering;
-/** Expressions and nested queries selected under the keys of the result fields; a record has no symbol keys. */
-interface Selection {
-  readonly [key: string]: TypedExpression | NestedQuery;
-  readonly [key: symbol]: never;
-}
-/** Query whose rows a selection nests as the value of a field: a query of any state and kind, such as a query of a relation. */
-type NestedQuery = QueryOf<SelectQueryState>;
-/** Record of the values of the expressions and of the nested rows of a selection. */
-type SelectionResult<S extends Selection> = { [K in keyof S]: FieldValue<S[K]>; };
-/** Value of a selected field: of an expression, or of the nested rows of a query as the result of executing it, for each member of a union of them. */
-type FieldValue<V> = V extends NestedQuery ? QueryResult<V["types"]> : ExpressionValue<V>;
-/** Relations whose records the nested queries of a selection select. */
-type SelectionUses<S extends Selection> = S[keyof S] extends (infer V) ? V extends NestedQuery ? V["types"]["uses"] : never : never;
-/** Value of a selected expression. */
-type ExpressionValue<E> = E extends AnyExpression<infer T> ? T : never;
-/** Values that the type of an expression encodes, such as in place of its value. */
-type ExpressionInput<E> = E extends AnyExpression<unknown, infer I> ? I : never;
-declare const helperFields: unique symbol;
-/** Marker of the input fields of a helper, carrying the keys selected by its callback. */
-interface HelperFields<Keys extends PropertyKey = PropertyKey> {
-  readonly [helperFields]: Keys;
-}
-/** Records with `Fields` added or replaced, for each branch of either record type; `any` stays `any`. */
-type MergeSelection<Previous, Fields> = Previous extends unknown ? Fields extends unknown ? MergeFields<RecordFields<Previous>, RecordFields<Fields>> & (IsAny<Previous> extends true ? Previous : unknown) : never : never;
-/** Fields with numeric keys represented as the string keys used in result records. */
-type RecordFields<Fields> = Fields extends unknown ? [Extract<keyof Fields, number>] extends [never] ? Fields : { [K in keyof Fields as K extends number ? `${K}` : K]: Fields[K]; } : never;
-/** Merge of normalized fields, retaining the previous value when an optional replacement is absent. */
-type MergeFields<Previous, Fields> = Simplify<{ [K in keyof Previous as K extends keyof Fields ? ({} extends Pick<Fields, K> ? K : never) : K]: K extends typeof helperFields // A branch selecting extra keys must not be reduced to one selecting fewer fields or none.
- ? Previous[K] | keyof Fields : K extends keyof Fields // A decoder can return undefined, so it cannot be excluded as merely an absent property.
- ? Previous[K] | Fields[K] : Previous[K]; } & { [K in keyof Fields as K extends keyof Previous ? ({} extends Pick<Fields, K> ? never : K) : K]: Fields[K]; }>;
-/** Value of column `K` of table `T` that an insert or an update sets: a value that its type encodes, `null` for a nullable column, or an expression of its values. */
-type ColumnValue<T extends AnyTable, K extends keyof T["columns"]> = ColumnValues<T>[K] | AnyExpression<Selectable<T>[K]>;
+/**
+ * Value of column `K` of table `T` that an insert or an update sets: a value that its type encodes, `null` for a nullable column, an expression of its values, or a query of one such value.
+ *
+ * A query may be `NULL` without its row, which PostgreSQL rejects for a column that is not nullable.
+ */
+type ColumnValue<T extends AnyTable, K extends keyof T["columns"]> = ColumnValues<T>[K] | AnyExpression<Selectable<T>[K]> | ScalarQuery<Selectable<T>[K] | null>;
 /** Key of a column of table `T` that an insert may omit, which gets its default: one that the database gives a value, as `hasDefault` marks it, or a nullable one, whose default is `NULL` unless the database declares another. */
 type OptionalColumnKey<T extends AnyTable> = { [K in keyof T["columns"]]: T["columns"][K]["attributes"]["hasDefault"] extends true ? K : null extends ColumnValues<T>[K] ? K : never; }[keyof T["columns"]];
 /** Record of an insert into table `T`: the values of its columns, which may omit a column with a default or a nullable column, or give it as `undefined`. */
 type InsertValues<T extends AnyTable> = { readonly [K in keyof T["columns"] as K extends OptionalColumnKey<T> ? never : K]: ColumnValue<T, K>; } & { readonly [K in OptionalColumnKey<T>]?: ColumnValue<T, K> | undefined; };
 /** Values of the columns of table `T` that an update sets; a column omitted or given as `undefined` keeps its value. */
 type UpdateValues<T extends AnyTable> = { readonly [K in keyof T["columns"]]?: ColumnValue<T, K> | undefined; };
-/** Argument of `update`: the values that it sets, or a callback that receives the columns of the changed rows and returns them. */
-type UpdateSet<T extends AnyTable> = UpdateValues<T> | ((columns: ColumnRefs<T>) => UpdateValues<T>);
+/** Argument of `update` of table `T` with schema context `C`: the values that it sets, or a callback that receives the columns and the queries of the relations of the changed rows and returns them. */
+type UpdateSet<T extends AnyTable, C extends SchemaContext = NoRelations> = UpdateValues<T> | ((columns: ColumnRefs<T> & RelationRefs<C>) => UpdateValues<T>);
 /** State `S` with the parts of `Changes` replaced. */
 type ChangeState<S extends SelectQueryState, Changes extends Partial<SelectQueryState>> = { readonly [K in keyof SelectQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
 /** Rows mode of a query of state `S` after a filter: `FilteredRows` of a query whose row is guaranteed, and the rows of other queries. */
@@ -801,6 +1108,8 @@ interface ScalarQuery<T = unknown> {
 }
 /** Value of query `Q` of one value in an expression. */
 type ScalarQueryValue<Q extends ScalarQuery> = Q[typeof scalarValue];
+/** Relations whose records `E`, an expression or a query of one value that a callback returns, selects: those of a query, as an expression does not carry the relations of its queries. */
+type OperandUses<E> = E extends ScalarQuery ? E["types"]["uses"] : never;
 /** State of a query of one value, which an expression takes. */
 interface ScalarQueryState extends SelectQueryState {
   readonly rows: "one" | "optional";
@@ -810,6 +1119,10 @@ interface ScalarQueryState extends SelectQueryState {
 interface ExpressionQueryState extends ScalarQueryState {
   readonly valueType: QueryValueType;
 }
+/** Query of one value of a table with the type of its value, such as of `get` or of an aggregate, which gives the expression of a function the decoding and the operators of its value. */
+interface TypedScalarQuery extends ScalarQuery {
+  readonly types: ExpressionQueryState;
+}
 /** Query of values of a table of any rows, such as of `pluck`, whose value is `T`, which `in` takes as a subquery of its values. */
 interface ValuesQuery<T = unknown> {
   readonly types: ValuesQueryState<T>;
@@ -823,7 +1136,7 @@ interface ValuesQueryState<T> extends SelectQueryState {
   readonly value: true;
 }
 /** State of a query whose rows are records, which `select` and `clearSelect` change. */
-type RecordQueryState$1 = SelectQueryState & {
+type RecordQueryState = SelectQueryState & {
   readonly value: false;
 };
 /** State of a query whose row no relation guarantees, which a filter keeps. */
@@ -849,10 +1162,10 @@ type ColumnValueType<T extends AnyTable, K extends keyof T["columns"]> = {
   readonly input: ColumnValues<T>[K];
   readonly operators: ColumnOperators<T, K>;
 };
-/** Type of the value of a query of expression `E`. */
-type ExpressionValueType<E extends TypedExpression> = {
-  readonly input: ExpressionInput<E>;
-  readonly operators: ExpressionOperators<E>;
+/** Type of the value of a query of `E`, an expression or a query of one value that a callback returns. */
+type OperandValueType<E extends TypedOperand> = {
+  readonly input: TypedOperandInput<E>;
+  readonly operators: TypedOperandOperators<E>;
 };
 /** State of a query of the value `V` of type `Type` of an aggregate or of `exists` over the rows of a query of state `S`, which always returns one row. */
 type AggregateState<S extends SelectQueryState, V, Type extends QueryValueType> = ChangeState<S, {
@@ -863,12 +1176,22 @@ type AggregateState<S extends SelectQueryState, V, Type extends QueryValueType>
   guaranteed: false;
   aggregate: true;
 }>;
+/** State of a query of the value `V` of type `Type` of an aggregate over the rows of a query of state `S`, whose argument is `E`, an expression or a query of one value that a callback returns. */
+type OperandAggregateState<S extends SelectQueryState, V, Type extends QueryValueType, E> = ChangeState<S, {
+  result: V;
+  valueType: Type;
+  rows: "one";
+  value: true;
+  guaranteed: false;
+  aggregate: true;
+  uses: S["uses"] | OperandUses<E>;
+}>;
 /** State of a query of the number of rows or of values among the rows of a query of state `S`. */
 type CountState<S extends SelectQueryState> = AggregateState<S, number, CountValueType>;
 /** State of a query of an aggregate of the values of column `K` of the rows of a query of state `S`, `NULL` without values other than `NULL`. */
 type ColumnAggregateState<S extends SelectQueryState, K extends keyof S["table"]["columns"]> = AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValueType<S["table"], K>>;
-/** State of a query of an aggregate of the values of expression `E` over the rows of a query of state `S`, `NULL` without values other than `NULL`. */
-type ExpressionAggregateState<S extends SelectQueryState, E extends TypedExpression> = AggregateState<S, ExpressionValue<E> | null, ExpressionValueType<E>>;
+/** State of a query of an aggregate of the values of `E`, an expression or a query of one value that a callback returns, over the rows of a query of state `S`, `NULL` without values other than `NULL`. */
+type OperandValueAggregateState<S extends SelectQueryState, E extends TypedOperand> = OperandAggregateState<S, OperandValue<E> | null, OperandValueType<E>, E>;
 /** Value `V` of a query of values whose `NULL` `coalesce` replaces with fallback `F`. */
 type CoalescedValue<V, F> = Exclude<V, null> | Extract<OperandValue<F>, null>;
 /** State of a query of many rows, which `limit` and `offset` apply to. */
@@ -893,7 +1216,7 @@ type OneRecordQueryState = OneRowQueryState & {
 declare class SelectQuery<out S extends SelectQueryState, out Kind extends SelectQueryKind = "unbound"> {
   readonly table: S["table"];
   readonly node: QueryNode;
-  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  /** Relations of the table in the schema the query starts from, which its callbacks receive. */
   readonly context: QueryContext;
   readonly types: S;
   /** Value of the query in an expression, for types only. */
@@ -903,22 +1226,22 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
   readonly then: QueryThen<S, Kind>;
   constructor(table: S["table"], node: QueryNode,
-  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  /** Relations of the table in the schema the query starts from, which its callbacks receive. */
   context: QueryContext, db?: AnyDb);
   /** Adds a filter combined with `AND` with the previous ones; a callback receives the columns and the queries of the relations of the table. */
-  where<Q extends QueryOf<UnguaranteedQueryState>>(this: Q, filter: WhereFilter<Q["types"]["table"], Q["types"]["schema"]>): Q;
+  where<Q extends QueryOf<UnguaranteedQueryState>>(this: Q, filter: QueryWhereFilter<Q["types"]>): Q;
   /**
    * Adds a filter combined with `AND` with the previous ones; a callback receives the columns and the queries of the relations of the table.
    *
    * A query of the record of a required relation, such as `field.form`, resolves to `null` without a record that passes the filter, or to `undefined` after `get` or `pluck`.
    */
-  where<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, filter: WhereFilter<S["table"], S["schema"]>): SelectQuery<FilteredState<S>, Kind>;
+  where<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, filter: QueryWhereFilter<S>): SelectQuery<FilteredState<S>, Kind>;
   /** Selects all columns of the table, replacing fields under their keys. */
-  select<S extends RecordQueryState$1, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, all: "*"): SelectQuery<ChangeState<S, {
+  select<S extends RecordQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, all: "*"): SelectQuery<ChangeState<S, {
     result: MergeSelection<S["result"], Selectable<S["table"]>>;
   }>, Kind>;
   /** Selects the listed columns, replacing fields under their keys. */
-  select<S extends RecordQueryState$1, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, ...keys: K[]): SelectQuery<ChangeState<S, {
+  select<S extends RecordQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, ...keys: K[]): SelectQuery<ChangeState<S, {
     result: MergeSelection<S["result"], Pick<Selectable<S["table"]>, K>>;
   }>, Kind>;
   /**
@@ -928,12 +1251,12 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Each expression is decoded with its type, so it must have one: a column, an operator result, or a fragment of `sql(type)`, but not of `sql<T>`.
    * A nested query is unbound, such as a query of a relation, or bound to the `Db` that runs the query; its rows become the value of its field as they become the result of an executed query.
    */
-  select<S extends RecordQueryState$1, Kind extends SelectQueryKind, Sel extends Selection>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => Sel): SelectQuery<ChangeState<S, {
+  select<S extends RecordQueryState, Kind extends SelectQueryKind, Sel extends Selection>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => Sel): SelectQuery<ChangeState<S, {
     result: MergeSelection<S["result"], SelectionResult<Sel>>;
     uses: S["uses"] | SelectionUses<Sel>;
   }>, Kind>;
   /** Removes all selected fields and keeps the other clauses. */
-  clearSelect<S extends RecordQueryState$1, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
+  clearSelect<S extends RecordQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
     result: EmptyRecord;
   }>, Kind>;
   /**
@@ -975,15 +1298,18 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /**
    * Replaces the selected fields with the expression returned by `callback`, limits the query to one row, and returns the value of the expression instead of a record.
    *
+   * `callback` receives the columns and the queries of the relations of the table.
+   * It may return a query of one value, such as of an aggregate of related records, which gives `NULL` without its row.
    * Without a row, it rejects with `NotFoundError`, or with `RequiredRelationError` when a required relation still guarantees the row, such as of `field.form`.
    * An optional or nullable query resolves to `undefined` without a row instead.
    * A `NULL` value is `null`.
    */
-  get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ChangeState<S, {
-    result: ExpressionValue<E>;
-    valueType: ExpressionValueType<E>;
+  get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<ChangeState<S, {
+    result: OperandValue<E>;
+    valueType: OperandValueType<E>;
     rows: OneValueRows<S["rows"]>;
     value: true;
+    uses: S["uses"] | OperandUses<E>;
   }>, Kind>;
   /**
    * Replaces the selected fields with a column and returns the value of the column of each row instead of a record.
@@ -999,13 +1325,16 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /**
    * Replaces the selected fields with the expression returned by `callback` and returns the value of the expression for each row instead of a record.
    *
+   * `callback` receives the columns and the queries of the relations of the table.
+   * It may return a query of one value, such as of an aggregate of related records, which gives `NULL` without its row.
    * It keeps whether the query returns an array or one value, such as after `take`, and how it handles a missing row, except that a nullable query resolves to `undefined` without a row.
    */
-  pluck<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ChangeState<S, {
-    result: ExpressionValue<E>;
-    valueType: ExpressionValueType<E>;
+  pluck<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<ChangeState<S, {
+    result: OperandValue<E>;
+    valueType: OperandValueType<E>;
     rows: ValueRows<S["rows"]>;
     value: true;
+    uses: S["uses"] | OperandUses<E>;
   }>, Kind>;
   /**
    * Replaces the selected fields with the number of rows of the query and returns the number instead of the rows.
@@ -1015,40 +1344,76 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<CountState<S>, Kind>;
   /** Replaces the selected fields with the number of the values of the column other than `NULL` among the rows of the query and returns it instead of the rows. */
   count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<CountState<S>, Kind>;
-  /** Replaces the selected fields with the number of the values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows. */
-  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<CountState<S>, Kind>;
+  /**
+   * Replaces the selected fields with the number of the values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandAggregateState<S, number, CountValueType, E>, Kind>;
   /** Replaces the selected fields with the number of the distinct values of the column other than `NULL` among the rows of the query and returns it instead of the rows. */
   countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<CountState<S>, Kind>;
-  /** Replaces the selected fields with the number of the distinct values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows. */
-  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<CountState<S>, Kind>;
+  /**
+   * Replaces the selected fields with the number of the distinct values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandAggregateState<S, number, CountValueType, E>, Kind>;
   /** Replaces the selected fields with the smallest value of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
   min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with the smallest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with the smallest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the largest value of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
   max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with the largest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with the largest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the sum of the values of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
   sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with the sum of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with the sum of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the average of the values of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values. */
   avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with the average of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values. */
-  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with the average of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with whether every value of the Boolean column other than `NULL` among the rows of the query is true and returns it instead of the rows, or `null` without such values. */
   every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with whether every value other than `NULL` of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without such values. */
-  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with whether every value other than `NULL` of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without such values.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with whether any value of the Boolean column among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`. */
   some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with whether any value of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`. */
-  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with whether any value of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the values of the text column other than `NULL` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values. */
   stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K, delimiter: string): SelectQuery<ColumnAggregateState<S, K>, Kind>;
-  /** Replaces the selected fields with the values other than `NULL` of the text expression returned by `callback` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values. */
-  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E, delimiter: string): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with the values other than `NULL` of the text expression returned by `callback` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values.
+   *
+   * `callback` receives the columns and the queries of the relations of the table and returns an expression or a query of one value.
+   */
+  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E, delimiter: string): SelectQuery<OperandValueAggregateState<S, E>, Kind>;
   /**
    * Replaces the selected fields with whether the query has a row and returns it instead of the rows, such as to filter by related records in `where`.
    *
@@ -1077,7 +1442,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It returns an expression or a query of one value, such as of an aggregate of related records, sorted in ascending order, `asc`, `desc`, or `orderBy` of one, or an array of them.
    * A selected field sorts by the value of the field, also when it changes from row to row, such as `random()`; a field of nested rows cannot be sorted by.
    */
-  orderBy<Q extends QueryOf<RecordQueryState$1>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, selected: SelectedRefs<Q["types"]["result"]>) => OrderTerms): Q;
+  orderBy<Q extends QueryOf<RecordQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, selected: SelectedRefs<Q["types"]["result"]>) => OrderTerms): Q;
   /**
    * Sorts the values of a query made by `get` or `pluck` by the sort keys returned by `callback`, after the sort keys of earlier calls.
    *
@@ -1114,7 +1479,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Inserts a record into the table of a query without clauses, such as a table of a `Db`, and resolves to the number of the inserted rows, `1`.
    *
    * A column omitted or given as `undefined` gets its default, so only columns marked with `hasDefault` and nullable columns may be omitted.
-   * A value is what the type of its column takes, `null` for `NULL`, or an expression, such as a `sql` fragment.
+   * A value is what the type of its column takes, `null` for `NULL`, an expression, such as a `sql` fragment, or a query of one value, which gives `NULL` without its row.
    * Select the fields that it returns after it, such as `insert(values).get("id")`.
    */
   insert<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: InsertValues<S["table"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], "one">, Kind>;
@@ -1125,15 +1490,26 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Select the fields that it returns for the inserted rows after it, such as `insertMany(records).select("id", "email")`, and match them to the records by a key rather than by their order, which PostgreSQL does not guarantee.
    */
   insertMany<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, records: readonly InsertValues<S["table"]>[]): MutationQuery<InitialMutationState<S["table"], S["schema"], "many">, Kind>;
+  /**
+   * Updates the rows that the filters of the query choose with the values that `callback` returns, and resolves to the number of the updated rows.
+   *
+   * `callback` receives the columns and the queries of the relations of the changed rows, such as to set a column from another one or from related records, and returns the values of the columns to update; a column omitted or given as `undefined` keeps its value.
+   * A value is what `insert` takes as a value, such as a query of an aggregate of related records.
+   * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
+   * A query without a filter must call `all` to update every row.
+   * Select the fields that it returns after it, with their values after the update, such as `update(callback).select("id")`.
+   */
+  update<S extends SelectQueryState, Kind extends SelectQueryKind, F extends (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => UpdateValues<S["table"]>>(this: SelectQuery<S, Kind>, callback: F): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"], OperandUses<ReturnType<F>[keyof ReturnType<F>]>>, Kind>;
   /**
    * Updates the rows that the filters of the query choose with the values of `set`, and resolves to the number of the updated rows.
    *
-   * `set` gives the values of the columns to update, or is a callback that receives the columns and returns them, such as to set a column from another one; a column omitted or given as `undefined` keeps its value.
+   * `set` gives the values of the columns to update, or is a callback that returns them; a column omitted or given as `undefined` keeps its value.
+   * A value is what `insert` takes as a value.
    * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
    * A query without a filter must call `all` to update every row.
    * Select the fields that it returns after it, with their values after the update, such as `update(set).select("id")`.
    */
-  update<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, set: UpdateSet<S["table"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
+  update<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, set: UpdateSet<S["table"], S["schema"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
   /**
    * Deletes the rows that the filters of the query choose, and resolves to the number of the deleted rows.
    *
@@ -1157,322 +1533,101 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
   /**
-   * Returns the node of the query as an operand of an expression, which lowering replaces with a scalar subquery of its value, or with `EXISTS` of its rows for a query of `exists`.
-   *
-   * It rejects a query of records or of rows `many`, which `ScalarQuery` rejects in types.
-   */
-  [operandNode](): ExpressionNode;
-  /**
-   * Returns the node of the query as the values of `in`, which lowering replaces with its statement.
-   *
-   * It rejects a query of records, which `ValuesQuery` rejects in types.
-   */
-  [valuesQueryNode](): NestedQueryNode;
-  /** Creates a query of the same kind and `Db` with the node changes applied. */
-  private derive;
-  /**
-   * Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
-   *
-   * It adds the changes of `take` to `changes`, which must leave the limit as it is.
-   */
-  private deriveTaken;
-  /** Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row. */
-  private deriveAggregate;
-  /** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and returns an expression; `delimiter` is the delimiter of `stringAgg`. */
-  private aggregateBy;
-  /** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
-  private addFilter;
-  /** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
-  private takeWhere;
-  /** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
-  private changeOneRow;
-  /** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
-  private rejectValue;
-  /** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
-  private rejectAggregate;
-}
-/** Select query bound to a `Db`, executed by awaiting it; every method returns a query bound to the same `Db`. */
-type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
-/** Select query of any state and kind. */
-type AnySelectQuery = SelectQuery<any, SelectQueryKind>;
-/** Type of a record of a query result, or of its value for a query made by `get`, `pluck`, or an aggregate method. */
-type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
-/** Table of a definition such as `defineFilter`: the table itself or a query over it with schema context `C`, such as `schema.form`. */
-type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
-/** Starts a query over a new occurrence of the table. */
-declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T>>;
-/** Runtime mark of the operators of `equalityOperators`, which tell that a type has SQL `=`. */
-declare const equalityBrand: unique symbol;
-/** Generic operator of `equalityOperators`, which gives the type it is added to SQL `=`. */
-interface EqualityOperator<S extends OperatorSignature> extends GenericOperator<S> {
-  readonly [equalityBrand]: true;
-}
-/** Key of the method of a query of a table that returns its node as the values of `in`, or rejects a query of records. */
-declare const valuesQueryNode: unique symbol;
-/** Signature of `in`: membership in a list of operands of the expression type, or in the values of a query, such as of `pluck`; an empty list or query yields `FALSE`. */
-interface InSignature extends OperatorSignature {
-  readonly method: <const L extends readonly Operand<this["T"], this["I"]>[] | ValuesQuery<NonNullable<this["T"]> | null>>(list: L) => Expression<L extends readonly unknown[] ? L extends readonly [] ? boolean : BooleanResult<this["T"] | OperandValue<L[number]>> : BooleanResult<this["T"] | (L extends ValuesQuery ? ValuesQueryValue<L> : never)>>;
-}
-/** Operators of `equalityOperators`. */
-type EqualityOperators = {
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
-};
-/** Tells whether operators `O` include an operator of `equalityOperators`, so that their type has SQL `=`. */
-type HasEquality<O> = true extends { [K in keyof O]: O[K] extends {
-  readonly [equalityBrand]: true;
-} ? true : false; }[keyof O] ? true : false;
-/**
- * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
- *
- * A type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
- */
-declare const equalityOperators: EqualityOperators;
-/** State of a query of `$select` in types: one record `R`, whose nested queries select records of relations `U`. */
-interface RecordQueryState<R = unknown, U extends UsedRelation = UsedRelation> extends QueryState {
-  readonly result: R;
-  readonly rows: "one";
-  readonly value: false;
-  readonly uses: U;
-}
-/** State of the query of `$select` of `Sel`: the record of the values of its expressions and the results of its queries. */
-type SelectionState<Sel extends Selection> = RecordQueryState<MergeSelection<EmptyRecord, SelectionResult<Sel>>, SelectionUses<Sel>>;
-/**
- * Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and the results of independent queries, selected in one statement.
- *
- * An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
- * A bound query executes on its `Db` when awaited.
- */
-declare class RecordQuery<out S extends RecordQueryState, out Kind extends SelectQueryKind = "unbound"> {
-  readonly node: RecordQueryNode;
-  readonly types: S;
-  /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-  readonly db: QueryDb<Kind>;
-  /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-  readonly then: QueryThen<S, Kind>;
-  constructor(node: RecordQueryNode, db?: AnyDb);
-  /**
-   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
+   * Returns the node of the query as an operand of an expression, which lowering replaces with a scalar subquery of its value, or with `EXISTS` of its rows for a query of `exists`.
    *
-   * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
+   * It rejects a query of records or of rows `many`, which `ScalarQuery` rejects in types.
    */
-  toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
-  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-  [operandNode](): never;
-}
-/** Query of `$select` of any state and kind. */
-type AnyRecordQuery = RecordQuery<any, SelectQueryKind>;
-declare const schemaBrand: unique symbol;
-/** Key of the relation definitions of a schema, which composition reads. */
-declare const schemaRelations: unique symbol;
-/** Tables by their keys; a key must not start with `$`, which is reserved for schema and `Db` members. */
-type Tables = Record<string, AnyTable>;
-/**
- * Immutable collection of tables and their relations with query entry points.
- *
- * A schema is not bound to a database, so queries built from it can be defined at module level.
- * A `Db` can execute such a query if its schema contains the tables and the selected relations of the query and every bound nested query belongs to that `Db`.
- */
-type Schema<T extends Tables, R extends SchemaRelations = EmptyRecord> = SchemaEntries<T, R> & SchemaMembers<T, R>;
-/** Query entry points; each access starts a query over a new table occurrence. */
-type SchemaEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: SelectQuery<InitialQueryState<T[K], TableContext<R, K>>>; };
-/** Members of a schema that composition reads: its tables and the relations of its tables. */
-interface SchemaContents<T extends Tables, R extends SchemaRelations> {
-  readonly [schemaBrand]: true;
-  /** Tables of the schema by their keys. */
-  readonly $tables: T;
-  /** Relation definitions by table key and relation name. */
-  readonly [schemaRelations]: R;
-}
-interface SchemaMembers<T extends Tables, R extends SchemaRelations> extends SchemaContents<T, R> {
+  [operandNode](): ExpressionNode;
   /**
-   * Creates a schema of the same tables with the relations of `relations` added, declared with `many` and `one` by their names under the keys of their tables.
+   * Returns the node of the query as the values of `in`, which lowering replaces with its statement.
    *
-   * A relation refers to a table of the schema by columns of SQL types that `=` compares; a relation that the schema already has is rejected.
+   * It rejects a query of records, which `ValuesQuery` rejects in types.
    */
-  $relations<S extends AnySchema, D extends RelationDeclarations<S["$tables"]>>(this: S, relations: D & CheckDeclarations<S["$tables"], D>): Schema<S["$tables"], MergeRelations<S[typeof schemaRelations] & DeclaredRelations<S["$tables"], D>>>;
+  [valuesQueryNode](): NestedQueryNode;
+  /** Creates a query of the same kind and `Db` with the node changes applied. */
+  private derive;
   /**
-   * Starts an unbound query of one record whose fields are the values of the expressions and the results of the queries of `selection`, selected in one statement.
+   * Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
    *
-   * The value of the field of a query is the result it gives when executed, such as an array of records or one value.
+   * It adds the changes of `take` to `changes`, which must leave the limit as it is.
    */
-  $select<Sel extends Selection>(selection: Sel): RecordQuery<SelectionState<Sel>>;
-}
-/** Schema of any tables and relations. */
-type AnySchema = SchemaContents<Tables, SchemaRelations>;
-/** Part of a schema definition: an object of tables by their keys, or a schema whose tables and relations it includes. */
-type SchemaPart = Tables | AnySchema;
-/**
- * Tables of the parts of a schema definition by their keys.
- *
- * A part typed as a union gives a union of tables, and parts of an array of unknown length give no tables, since any of them may be missing.
- */
-type SchemaTables<P extends readonly SchemaPart[]> = ComposeParts<P>["tables"] extends (infer T extends Tables) ? { [K in keyof T]: T[K]; } : never;
-/** Relations of the parts of a schema definition by table key and relation name, read as `SchemaTables` reads the tables. */
-type SchemaPartRelations<P extends readonly SchemaPart[]> = ComposeParts<P>["relations"] extends (infer R extends SchemaRelations) ? MergeRelations<R> : never;
-/** Tables and relations of the parts of a schema definition, intersected. */
-interface PartContents {
-  readonly tables: Tables;
-  readonly relations: SchemaRelations;
-}
-type ComposeParts<P extends readonly SchemaPart[], Composed extends PartContents = {
-  tables: EmptyRecord;
-  relations: EmptyRecord;
-}> = P extends readonly [infer First extends SchemaPart, ...infer Rest extends readonly SchemaPart[]] ? ComposeParts<Rest, Composed & ReadPart<First>> : P extends readonly [...infer Rest extends readonly SchemaPart[], infer Last extends SchemaPart] ? ComposeParts<Rest, Composed & ReadPart<Last>> : Composed;
-type ReadPart<P extends SchemaPart> = P extends SchemaContents<infer T, any> ? {
-  tables: T;
-  relations: P[typeof schemaRelations];
-} : {
-  tables: P;
-  relations: EmptyRecord;
-};
-/**
- * Defines a schema of the tables of `parts`, keyed by their names in queries.
- *
- * A part is an object of tables by their keys or another schema, whose tables and relations the new schema includes as they are, so queries built from that schema run on the new one.
- * A key of two different tables, a table under two keys, and two different definitions of a relation of a table are rejected; the same table under the same key or the same relation in several parts is one.
- */
-declare function defineSchema<P extends SchemaPart[]>(...parts: P): Schema<SchemaTables<P>, SchemaPartRelations<P>>;
-declare const sourceTable: unique symbol;
-declare const sourceKey: unique symbol;
-/** Runtime mark of the declarations of `many` and `one`. */
-declare const declarationBrand: unique symbol;
-/** Kind of a relation: `many` related records, or `one` related record at most. */
-type RelationKind = "many" | "one";
-/** Relation of a table of a schema to the records of table `Target`, which has key `TargetKey` in the schema. */
-interface Relation<Kind extends RelationKind = RelationKind, Target extends AnyTable = AnyTable, TargetKey extends string = string, Required extends boolean = boolean> {
-  readonly kind: Kind;
-  readonly target: Target;
-  readonly targetKey: TargetKey;
-  /** Whether every record of the table has its related record, so that a query of a relation `one` without a filter rejects without it rather than giving `null`; `false` for a relation `many`. */
-  readonly required: Required;
+  private deriveTaken;
+  /** Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row. */
+  private deriveAggregate;
+  /** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and the relations and returns an expression or a query of one value; `delimiter` is the delimiter of `stringAgg`. */
+  private aggregateBy;
+  /** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
+  private addFilter;
+  /** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
+  private takeWhere;
+  /** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
+  private changeOneRow;
+  /** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
+  private rejectValue;
+  /** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
+  private rejectAggregate;
 }
+/** Select query bound to a `Db`, executed by awaiting it; every method returns a query bound to the same `Db`. */
+type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
+/** Select query of any state and kind. */
+type AnySelectQuery = SelectQuery<any, SelectQueryKind>;
+/** Type of a record of a query result, or of its value for a query made by `get`, `pluck`, or an aggregate method. */
+type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
+/** Table of a definition such as `defineExpression`: the table itself or a query over it with schema context `C`, such as `schema.form`. */
+type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
+/** Starts a query over a new occurrence of the table. */
+declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T>>;
+/** First operand of `coalesce`, `greatest`, and `least`: an expression with a type, or a query of one value, such as of an aggregate, whose type decodes the result and gives it its operators. */
+type TypedOperand = TypedExpression | TypedScalarQuery;
+/** Values that the type of the first operand `F` encodes. */
+type TypedOperandInput<F> = F extends TypedScalarQuery ? F["types"]["valueType"]["input"] : ExpressionInput<F>;
+/** Operators of the type of the first operand `F`. */
+type TypedOperandOperators<F> = F extends TypedScalarQuery ? F["types"]["valueType"]["operators"] : F extends TypedExpression ? ExpressionOperators<F> : never;
+/** Operand of `coalesce`, `greatest`, and `least` after the first operand `F`: a value that its type encodes, or an expression or a query of one value of its values. */
+type FollowingOperand<F> = Operand<OperandValue<F>, TypedOperandInput<F>>;
+/** `null` when every operand can be `NULL`: the first operand `F` and the following operands `R`. */
+type NullOfEveryOperand<F, R extends readonly unknown[]> = null extends OperandValue<F> ? number extends R["length"] ? null : { [K in keyof R]: null extends OperandValue<R[K]> ? never : true; }[number] extends never ? null : never : never;
+/** Result of a function of the first operand `F` and the following operands `R` that is `NULL` only when every operand is, whose operands all have the values of `F`. */
+type NullSkippingResult<F, R extends readonly unknown[]> = Expression<Exclude<OperandValue<F>, null> | NullOfEveryOperand<F, R>, TypedOperandOperators<F>, TypedOperandInput<F>>;
 /**
- * Relation of a table of a schema as `$relations` defines it: the columns of its keys, compared by SQL `=` in order.
+ * Returns the first of its operands other than `NULL`, such as `coalesce(field.hint, "")`, as an expression usable wherever a column is.
  *
- * Composition includes a definition as it is, so a relation that several parts include is one definition.
+ * `first` is an expression with a type or a query of one value; its type decodes the result and gives it its operators, and encodes plain values among `rest`.
+ * A query without its row is `NULL` here, unlike with the method `coalesce` of a query, which keeps a missing row missing.
  */
-interface RelationDefinition extends Relation {
-  readonly name: string;
-  /** Key of the source table. */
-  readonly key: string;
-  readonly source: AnyTable;
-  readonly from: readonly string[];
-  readonly to: readonly string[];
-}
-/** Relation `N` of the table under key `K` of a schema, of type `R`, whose records a query selects. */
-interface UsedRelation<K extends string = string, N extends string = string, R extends Relation = Relation> {
-  readonly key: K;
-  readonly name: N;
-  readonly relation: R;
-}
-/** Relations of schema relations `R` that the queries of a `Db` of the schema may select. */
-type UsableRelation<R extends SchemaRelations> = { [K in keyof R & string]: { [N in keyof R[K] & string]: UsedRelation<K, N, R[K][N]>; }[keyof R[K] & string]; }[keyof R & string];
-/** Relations of the tables of a schema by table key and relation name. */
-type SchemaRelations = {
-  readonly [key: string]: TableRelations;
-};
-/** Relations of a table of a schema by relation name. */
-type TableRelations = {
-  readonly [name: string]: Relation;
-};
+declare function coalesce<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
 /**
- * Declaration of a relation by `many` or `one`, which `$relations` of a schema defines for a table of type `Source` with key `From` of the source table.
+ * Returns the largest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
  *
- * `Source` and `From` only type the keys of the source table.
+ * `first` is an expression with a type or a query of one value; its type decodes the result and gives it its operators, and encodes plain values among `rest`.
  */
-interface RelationDeclaration<Kind extends RelationKind, Source extends AnyTable, Target extends AnyTable, From = unknown, Required extends boolean = boolean> {
-  readonly [declarationBrand]: true;
-  readonly kind: Kind;
-  readonly target: Target;
-  readonly from: readonly string[];
-  readonly to: readonly string[];
-  readonly required: Required;
-  readonly [sourceTable]?: (source: Source) => void;
-  readonly [sourceKey]?: From;
-}
-/** Column key of table `T` whose type has SQL `=`, which a relation can compare. */
-type EqualityKey<T extends AnyTable> = { [K in keyof T["columns"]]: HasEquality<ColumnOperators<T, K>> extends true ? K : never; }[keyof T["columns"]] & string;
-/** Key of a relation in table `T`: a column key, or a non-empty list of them for a composite key. */
-type RelationKey<T extends AnyTable> = EqualityKey<T> | readonly [EqualityKey<T>, ...EqualityKey<T>[]];
-/** Key of table `T` with as many columns as key `From`. */
-type MatchingKey<T extends AnyTable, From> = From extends string ? EqualityKey<T> : { readonly [I in keyof From]: EqualityKey<T>; };
-/** Keys of a relation: the columns `from` of the source table equal the columns `to` of the target table, in order. */
-interface RelationKeys<Target extends AnyTable, From> {
-  readonly from: From;
-  readonly to: MatchingKey<Target, From>;
-}
-/** Keys of a relation `one`, as in `RelationKeys`, and whether the relation is required. */
-interface OneRelationKeys<From, To> {
-  readonly from: From;
-  readonly to: To;
-  /** Whether every record has its related record, such as by a foreign key on columns `from` that are not nullable, so that a query of the relation without a filter rejects without it rather than giving `null`. */
-  readonly required?: boolean;
-}
-/** Members of the keys `K` of a relation `one` with only `required` typed, so that a call infers `K` with `required` as optional as it is, and reports a wrong key at its own member. */
-type RequiredMember<K> = { readonly [P in keyof K]: P extends "required" ? K[P] : unknown; };
-/** Whether the keys `K` of a relation `one` make it required: only where they set `required` to `true`, and `boolean` where `required` may be `true` or missing, such as `required?: true`. */
-type DeclaredRequiredOf<K> = K extends unknown ? "required" extends keyof K ? K extends {
-  readonly required: infer Required;
-} ? IsTrue<Required> : IsTrue<K["required" & keyof K] | undefined> : false : never;
-/** `true` for `true`, and `false` for other values, such as `false` and `undefined`; a union gives the union of their results. */
-type IsTrue<T> = T extends true ? true : false;
-/** Declarations of `$relations` of a schema of tables `T`: relations by name, for tables by their keys. */
-type RelationDeclarations<T extends Tables> = { readonly [K in keyof T]?: {
-  readonly [name: string]: RelationDeclaration<RelationKind, T[K], T[keyof T]>;
-}; };
+declare function greatest<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
 /**
- * Declarations `D` of `$relations` checked by the names they use: relations of the tables of `T` under their keys, and no other keys.
+ * Returns the smallest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
  *
- * Declarations under the names of `D` get their source table from this type even where the index signature of `RelationDeclarations` gives way to a member of `Object`, such as for a relation named `toString`.
- * A relation name must not be a column key of its table or start with `$`, since the references that the callback of `select` gets have both.
+ * `first` is an expression with a type or a query of one value; its type decodes the result and gives it its operators, and encodes plain values among `rest`.
  */
-type CheckDeclarations<T extends Tables, D> = { readonly [K in keyof D]: [TableKey<T, K>] extends [never] ? never : undefined extends D[K] ? D[K] : { readonly [N in keyof D[K]]: `${N & (string | number)}` extends ReservedName<T[TableKey<T, K>]> ? never : RelationDeclaration<RelationKind, T[TableKey<T, K>], T[keyof T], RelationKey<T[TableKey<T, K>]>>; }; };
-/** Names that a relation of table `T` cannot have: the keys of its columns, and names starting with `$`. */
-type ReservedName<T extends AnyTable> = `${keyof T["columns"] & (string | number)}` | `$${string}`;
-/** Key of tables `T` written as key `K`, such as `1` for `"1"`, as object keys are strings at runtime. */
-type TableKey<T extends Tables, K> = { [P in keyof T]: `${P & (string | number)}` extends `${K & (string | number)}` ? P : never; }[keyof T];
-/** Relations that declarations `D` of a schema of tables `T` define, by table key and relation name, as strings like the keys of objects. */
-type DeclaredRelations<T extends Tables, D> = { [K in keyof D as K extends number ? `${K}` : K]: { [N in keyof D[K] as N extends number ? `${N}` : N]: D[K][N] extends RelationDeclaration<infer Kind, never, infer Target, unknown, infer Required> ? Relation<Kind, Target, KeyOfTable<T, Target>, Required> : never; }; };
-/** Column key of relation key `K`: the key itself, or a column of a composite key. */
-type RelationColumn<K> = K extends readonly unknown[] ? K[number] : K;
-/** Check of key `To` of a relation `one` that rejects it when its columns include no key of table `Target`, as far as the types tell. */
-type TargetKeyCheck<Target extends AnyTable, To> = [ContainsKey<Target, RelationColumn<To>>] extends [false] ? {
-  readonly to: MissingKey<KeyOf<Target["keys"]>>;
-} : unknown;
-/** Type that a key `to` of a relation `one` without a key of its target is checked against, naming the keys of the target. */
-interface MissingKey<Keys> {
-  readonly "columns to must include a key of the target": Keys;
-}
-/** Key of table `Target` among tables `T`, as a string like the keys of objects. */
-type KeyOfTable<T extends Tables, Target> = { [K in keyof T]: [T[K]] extends [Target] ? [Target] extends [T[K]] ? K extends number ? `${K}` : K & string : never : never; }[keyof T];
-/** Relations of `R` by table key, with the relations under the same key merged. */
-type MergeRelations<R> = { [K in keyof R]: { [N in keyof R[K]]: R[K][N]; }; };
-/** Relations of the schema that a query starts from, by table key, and the key of the table of the query there. */
-interface SchemaContext<R extends SchemaRelations = SchemaRelations, K extends string = string> {
-  readonly relations: R;
-  readonly key: K;
-}
-/** Schema context of a query whose table has no relations, such as one of `from(table)`. */
-type NoRelations = SchemaContext<EmptyRecord, string>;
-/** Schema context of the queries of the table under key `K` of a schema of relations `R`, whose keys are strings, as object keys are at runtime. */
-type TableContext<R extends SchemaRelations, K> = K extends keyof R ? [keyof R[K]] extends [never] ? NoRelations : SchemaContext<R, K & string> : K extends number ? TableContext<R, `${K}`> : NoRelations;
+declare function least<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
+/** Condition of a branch of `caseWhen`: a predicate, or a query of one Boolean value, such as of `exists`. */
+type CaseCondition = Predicate | ScalarQuery<boolean | null>;
+/** Value of a branch of `caseWhen` of a type of values `T` that encodes values `I`: an operand of the type, or a plain `null`. */
+type CaseValue<T, I> = Operand<T, I> | null;
+/** Branch of `caseWhen`: a condition and the value of the result when it holds. */
+type CaseBranch<T, I> = readonly [condition: CaseCondition, value: CaseValue<T, I>];
+/** Value of `caseWhen` of a type of values `T` whose branches and fallback have the values `V`, of which one gives the result. */
+type CaseResult<T, V> = Exclude<T, null> | Extract<OperandValue<V>, null>;
 /**
- * Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+ * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `NULL` when none holds.
  *
- * A composite key lists its columns in arrays of the same length.
+ * `type` decodes the result and gives it its operators, and a plain value of a branch is cast to it, so that PostgreSQL does not take plain values for text.
  */
-declare function many<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>>(target: Target, keys: RelationKeys<Target, From>): RelationDeclaration<"many", Source, Target, From, false>;
+declare function caseWhen<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>, branches: NoInfer<readonly CaseBranch<Output, Input>[]>): Expression<Exclude<Output, null> | null, O, Input>;
 /**
- * Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+ * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `otherwise` when none holds.
  *
- * A composite key lists its columns in arrays of the same length.
- * The columns `to` must include a key of `target`, primary or unique, so that they match at most one record.
- * Without the record, a query of the relation gives `null`, and a query of a relation declared with `required: true` rejects unless it filters the record.
- * Set `required: true` only where the database guarantees the record, such as by a foreign key on columns `from` that are not nullable.
+ * `type` decodes the result and gives it its operators, and a plain value of a branch or of `otherwise` is cast to it, so that PostgreSQL does not take plain values for text.
  */
-declare function one<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>, const To extends MatchingKey<Target, From>, const Keys extends object = EmptyRecord>(target: Target, keys: OneRelationKeys<From, To> & RequiredMember<Keys> & TargetKeyCheck<Target, To>): RelationDeclaration<"one", Source, Target, From, NoInfer<DeclaredRequiredOf<Keys>>>;
+declare function caseWhen<Output, Input, O extends OperatorDefinitions, const B extends readonly CaseBranch<Output, Input>[], const E extends CaseValue<Output, Input>>(type: Type<Output, Input, O, any>, branches: B, otherwise: E): Expression<CaseResult<Output, B[number][1] | E>, O, Input>;
 /**
  * State in types of a query that inserts, updates, or deletes rows: its table and the relations of its schema, the rows mode of the rows it changes, and its result, which is their number until a selection returns their fields.
  *
@@ -1486,8 +1641,8 @@ interface MutationQueryState extends QueryState {
   /** Whether the query returns the fields of the rows it changes rather than their number. */
   readonly returning: boolean;
 }
-/** State of a query that inserts, updates, or deletes rows of table `T` with schema context `C` in rows mode `Rows` and returns their number. */
-interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows extends ResultRows> extends MutationQueryState {
+/** State of a query that inserts, updates, or deletes rows of table `T` with schema context `C` in rows mode `Rows` and returns their number, whose values select records of relations `U`. */
+interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows extends ResultRows, U extends UsedRelation = never> extends MutationQueryState {
   readonly table: T;
   readonly schema: C;
   readonly changed: Rows;
@@ -1495,7 +1650,7 @@ interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows
   readonly result: number;
   readonly rows: "one";
   readonly value: true;
-  readonly uses: never;
+  readonly uses: U;
 }
 /** State `S` of a mutation with the parts of `Changes` replaced. */
 type ChangeMutationState<S extends MutationQueryState, Changes extends Partial<MutationQueryState>> = { readonly [K in keyof MutationQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
@@ -1526,6 +1681,14 @@ type ValueState$1<S extends MutationQueryState, V, Rows extends ResultRows> = Ch
   value: true;
   returning: true;
 }>;
+/** State of a mutation of state `S` that returns the value of `E`, an expression or a query of one value that a callback returns, of each row it changes in rows mode `Rows`. */
+type OperandState<S extends MutationQueryState, E extends TypedOperand, Rows extends ResultRows> = ChangeMutationState<S, {
+  result: OperandValue<E>;
+  rows: Rows;
+  value: true;
+  returning: true;
+  uses: S["uses"] | OperandUses<E>;
+}>;
 /**
  * Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
  *
@@ -1536,7 +1699,7 @@ type ValueState$1<S extends MutationQueryState, V, Rows extends ResultRows> = Ch
 declare class MutationQuery<out S extends MutationQueryState, out Kind extends SelectQueryKind = "unbound"> {
   readonly table: S["table"];
   readonly node: MutationNode;
-  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  /** Relations of the table in the schema the query starts from, which its callbacks receive. */
   readonly context: QueryContext;
   readonly types: S;
   /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
@@ -1544,7 +1707,7 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
   /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
   readonly then: QueryThen<S, Kind>;
   constructor(table: S["table"], node: MutationNode,
-  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  /** Relations of the table in the schema the query starts from, which its callbacks receive. */
   context: QueryContext, db?: AnyDb);
   /** Returns all columns of each changed row, replacing fields under their keys, instead of the number of the rows. */
   select<S extends RecordMutationState, Kind extends SelectQueryKind>(this: MutationQuery<S, Kind>, all: "*"): MutationQuery<RecordsState<S, Selectable<S["table"]>>, Kind>;
@@ -1566,13 +1729,18 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
   /**
    * Returns the value of the expression that `callback` returns for the changed row instead of the number of the rows, in a query that changes one row, such as of `insert` or `find`.
    *
+   * `callback` receives what the callback of `select` receives, and may return a query of one value, which gives `NULL` without its row.
    * A query of a nullable row resolves to `undefined` without the row.
    */
-  get<S extends OneRowMutationState, Kind extends SelectQueryKind, E extends TypedExpression>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): MutationQuery<ValueState$1<S, ExpressionValue<E>, OneValueRows<S["changed"]>>, Kind>;
+  get<S extends OneRowMutationState, Kind extends SelectQueryKind, E extends TypedOperand>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): MutationQuery<OperandState<S, E, OneValueRows<S["changed"]>>, Kind>;
   /** Returns the value of a column of each changed row instead of the number of the rows, keeping whether the query returns an array or one value. */
   pluck<S extends MutationQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], ValueRows<S["changed"]>>, Kind>;
-  /** Returns the value of the expression that `callback` returns for each changed row instead of the number of the rows, keeping whether the query returns an array or one value. */
-  pluck<S extends MutationQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): MutationQuery<ValueState$1<S, ExpressionValue<E>, ValueRows<S["changed"]>>, Kind>;
+  /**
+   * Returns the value of the expression that `callback` returns for each changed row instead of the number of the rows, keeping whether the query returns an array or one value.
+   *
+   * `callback` receives what the callback of `select` receives, and may return a query of one value, which gives `NULL` without its row.
+   */
+  pluck<S extends MutationQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): MutationQuery<OperandState<S, E, ValueRows<S["changed"]>>, Kind>;
   /**
    * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
    *
@@ -1583,7 +1751,7 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
   [operandNode](): never;
   /** Creates a mutation of the same kind and `Db` with the node changes applied. */
   private derive;
-  /** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and returns an expression, of each changed row. */
+  /** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and the relations and returns an expression or a query of one value, of each changed row. */
   private deriveValue;
 }
 /** Query of any state and kind that inserts, updates, or deletes rows. */
@@ -1945,7 +2113,7 @@ type Db<T extends Tables, R extends SchemaRelations = EmptyRecord> = DbEntries<T
 /** Bound query entry points; each access starts a query over a new table occurrence. */
 type DbEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: BoundSelectQuery<InitialQueryState<T[K], TableContext<R, K>>>; };
 /** Bound or unbound query over a table of `T`, of `$select`, or that changes the rows of a table of `T`, that selects records only of relations of `R`, or a query of SQL text. */
-type DbQuery<T extends Tables, R extends SchemaRelations> = QueryOf<DbQueryState<T[keyof T], UsableRelation<R>>> | RecordQuery<RecordQueryState<unknown, UsableRelation<R>>, SelectQueryKind> | MutationQuery<DbMutationState<T[keyof T], UsableRelation<R>>, SelectQueryKind> | SqlQuery<SqlQueryState>;
+type DbQuery<T extends Tables, R extends SchemaRelations> = QueryOf<DbQueryState<T[keyof T], UsableRelation<R>>> | RecordQuery<RecordQueryState$1<unknown, UsableRelation<R>>, SelectQueryKind> | MutationQuery<DbMutationState<T[keyof T], UsableRelation<R>>, SelectQueryKind> | SqlQuery<SqlQueryState>;
 /** State of a query that a `Db` can execute: over table `T`, selecting records only of relations `U`. */
 interface DbQueryState<T extends AnyTable, U extends UsedRelation> extends QueryStateOf<T> {
   readonly uses: U;
@@ -1978,7 +2146,7 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
    */
   $execute<Q extends DbQuery<T, R>>(query: Q): Promise<QueryResult<Q["types"]>>;
   /**
-   * Starts a query of one record whose fields are the values of the expressions and the results of the queries of `selection`, selected in one statement when awaited.
+   * Starts a query of one record whose fields are the values of the expressions and of the literals and the results of the queries of `selection`, selected in one statement when awaited.
    *
    * A query of `selection` is unbound or bound to this `Db`, and the value of its field is the result it gives when executed, such as an array of records or one value.
    */
@@ -2222,6 +2390,8 @@ interface SelectNode<From extends SourceNode | undefined = SourceNode | undefine
   readonly offset: ExpressionNode | undefined;
   /** Required relation that guarantees the row of the query, such as `field.form`; see `ResultPlan`. */
   readonly guaranteedBy: string | undefined;
+  /** Template of the records of a query with literals; see `ResultPlan`. */
+  readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
 }
 /** Assignment of `SET` of an update: the value of the column under `key`. */
 interface AssignmentNode {
@@ -2236,6 +2406,8 @@ interface AssignmentNode {
 interface MutationParts<Field> extends ResultMode {
   readonly target: TableSourceNode;
   readonly returning: readonly Field[] | undefined;
+  /** Template of the records of a mutation with literals; see `ResultPlan`. */
+  readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
 }
 /** Insert statement of rows of `VALUES`. */
 interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
@@ -2308,27 +2480,90 @@ interface BaseOperators {
 }
 /** Operators of ordered types: those of `equalityOperators`, and `lt`, `lte`, `gt`, and `gte` comparing with operands of the expression type. */
 declare const orderingOperators: {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
   lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
 };
+/** Operators of the built-in types of numbers: those of `orderingOperators`. */
+type NumberTypeOperators = MergeOperators<NoOperators, typeof orderingOperators>;
 /** Signature of pattern matching: patterns stay strings even when the text values are transformed. */
 interface PatternSignature extends OperatorSignature {
   readonly method: <V extends Operand<string>>(pattern: V) => Expression<BooleanResult<this["T"] | OperandValue<V>>>;
 }
+/** Signature of `lower`, `upper`, and `trim`: a value of `text`, whatever the representation of the text values, and `NULL` when the text can be. */
+interface TextConversionSignature extends OperatorSignature {
+  readonly method: () => Expression<string | (null extends this["T"] ? null : never), TextTypeOperators>;
+}
+/** Signature of `length`: the number of characters of the text, and `NULL` when the text can be. */
+interface TextLengthSignature extends OperatorSignature {
+  readonly method: () => Expression<number | (null extends this["T"] ? null : never), NumberTypeOperators>;
+}
+/** Operators of `textOperators`. */
+type TextOperators = {
+  like: GenericOperator<PatternSignature, AnyExpression<string | null>>;
+  ilike: GenericOperator<PatternSignature, AnyExpression<string | null>>;
+  lower: GenericOperator<TextConversionSignature, AnyExpression<string | null>>;
+  upper: GenericOperator<TextConversionSignature, AnyExpression<string | null>>;
+  trim: GenericOperator<TextConversionSignature, AnyExpression<string | null>>;
+  length: GenericOperator<TextLengthSignature, AnyExpression<string | null>>;
+};
+/** Operators of the built-in text types: those of `orderingOperators` and `textOperators`. */
+type TextTypeOperators = MergeOperators<MergeOperators<NoOperators, typeof orderingOperators>, TextOperators>;
 /**
- * Operators of text types: pattern matching with `LIKE` and `ILIKE`.
+ * Operators of text types: pattern matching with `LIKE` and `ILIKE`, `lower` and `upper`, which convert the case of the text, `trim`, which removes spaces from both of its ends, and `length`, which counts its characters.
  *
  * A string pattern is sent as it is; `param(type, pattern)` encodes it with a type.
  */
-declare const textOperators: {
-  like: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-  ilike: GenericOperator<PatternSignature, AnyExpression<string | null, unknown>>;
-};
+declare const textOperators: TextOperators;
+/** Condition that always holds, such as for a branch of `and` built in code: `and(check, isAdmin ? TRUE : other)`. */
+declare const TRUE: Expression<boolean>;
+/** Condition that never holds, such as for a branch of `or` built in code: `or(check, isAdmin ? other : FALSE)`. */
+declare const FALSE: Expression<boolean>;
+/**
+ * Defines a reusable expression of a table, which the callbacks of queries over the table call with their columns and any further arguments, such as to filter by it and select it in one query.
+ *
+ * `expression` returns an expression or a query of one value, and a call has its type, so that a selected field has its values and an expression has its operators.
+ * Defined with a query of a schema or a `Db`, such as `schema.form`, it receives the queries of the relations of the table in that schema, and queries whose schema has them can call it.
+ * Defined with a table, it receives only the columns, and every query of the table can call it, also one without relations, such as of `from`.
+ */
+declare function defineExpression<T extends AnyTable, R extends AnyExpression | ScalarQuery, A extends unknown[], C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, expression: (columns: ColumnRefs<T> & RelationRefs<C>, ...args: A) => R): (columns: ColumnRefs<T> & RelationRefs<C>, ...args: A) => R;
+/** Keys of the columns among references `R`, without the queries of relations. */
+type ColumnRefKey<R> = { [K in keyof R]: R[K] extends AnyExpression ? K : never; }[keyof R];
+/** Type that a key of the object of `matches` is checked against when it is not a column of its references, naming the columns. */
+interface NotAColumn<Keys> {
+  readonly "keys must be columns of the references": Keys;
+}
+/** Value of column `E` in the object of `matches`: an operand of its `eq`, or `null` when its input type includes it. */
+type MatchValue<E> = (E extends TypedExpression ? ExpressionOperators<E> extends {
+  readonly eq: EqualityOperator<ComparisonSignature>;
+} ? Operand<ExpressionValue<E>, ExpressionInput<E>> : EqOperand<E> : EqOperand<E>) | (null extends ExpressionInput<E> ? null : never);
+/**
+ * Check of object `V` of `matches` against references `R`, which gives each of its keys the value of its column.
+ *
+ * It maps the keys of the object rather than those of the references, so that a call reads the operands of only the columns it matches.
+ */
+type MatchCheck<R, V> = { readonly [K in keyof V]: K extends ColumnRefKey<R> ? MatchValue<R[K]> : NotAColumn<ColumnRefKey<R>>; };
+/** `null` that matching expression `E` with value `V` adds to the result; `never` when `V` is `null`, since `IS NULL` is never `NULL`. */
+type MatchNull<E, V> = V extends null ? never : E extends TypedExpression ? ExpressionOperators<E> extends {
+  readonly eq: EqualityOperator<ComparisonSignature>;
+} ? null extends ExpressionValue<E> | OperandValue<V> ? null : never : CustomEqNull<E> : CustomEqNull<E>;
+/** `null` of the result of a custom `eq` of expression `E`. */
+type CustomEqNull<E> = E extends {
+  eq: (...args: never[]) => AnyExpression<infer O>;
+} ? Extract<O, null> : never;
+/** Value of `matches` of object `V` over references `R`: `boolean`, or also `null` when a comparison of a column can be `NULL`. */
+type MatchResult<R, V> = boolean | (V extends unknown ? { [K in keyof V]-?: K extends keyof R ? MatchNull<R[K], V[K]> : never; }[keyof V] : never);
+/**
+ * Creates a Boolean expression of an object of column values over the columns that a callback of a query receives, such as `matches(form, { published: true })`.
+ *
+ * Each value matches its column as in an object passed to `where`: `null` by `IS NULL`, and another value by the `eq` operator of the column; all of them must match, and an empty object is `TRUE`.
+ * Unlike such an object in `and`, `or`, and `not`, the expression refers to the columns it receives whichever query it is used in, and applies wherever an expression does, such as in `select`.
+ */
+declare function matches<R extends object, const V extends { readonly [K in ColumnRefKey<R>]?: unknown; }>(columns: R, values: V & MatchCheck<R, V>): Expression<MatchResult<R, V>>;
 /**
  * State of the query that the callback of a helper of table `T` with schema context `C` receives: the fields of the query the helper is applied to, and all its rows.
  *
@@ -2448,4 +2683,4 @@ declare function identifier(...names: [string, ...string[]]): UntypedExpression;
  */
 declare function param<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>, value: Input): Expression<Output, O, Input>;
 declare function param<E extends AnyExpression, V extends (E extends AnyExpression<infer T, infer I> ? Operand<T, I> : never)>(type: E, value: V): V extends AnyExpression ? V : V extends ScalarQuery ? AnyExpression<ScalarQueryValue<V>> : E;
-export { RelationDeclarations as $, ToColumns as $n, SelectedRefs as $t, TestFixture as A, EmptyRecord as An, OperatorDefinitions as Ar, FilteredStateRows as At, InitialSqlQueryState as B, compare as Bn, ExpressionInput as Bt, Database as C, FilteredRows as Cn, Column as Cr, EqualityOperator as Ct, TransactionCoordinator as D, ResultByRows as Dn, BoundOperators as Dr, equalityOperators as Dt, createDatabase as E, QueryResult as En, ToColumn as Er, InSignature as Et, AnyQuery as F, SelectQueryState as Fn, from as Ft, MutationQuery as G, ColumnOperators as Gn, SelectionResult as Gt, SqlQueryState as H, AnyTable as Hn, MergeSelection as Ht, SelectQueryKind as I, BooleanResult as In, ColumnValue as It, MergeRelations as J, KeyColumns as Jn, OrderDirection as Jt, MutationQueryState as K, ColumnShape as Kn, SelectionUses as Kt, AnySqlQuery as L, ComparisonSignature as Ln, InsertValues as Lt, TestHooks as M, QueryState as Mn, GenericOperatorImplementation as Mr, ScalarQuery as Mt, TestTransactionOptions as N, QueryStateOf as Nn, OperatorSignature as Nr, SelectQuery as Nt, OpenedTestFixture as O, ValueRows as On, MergeOperators as Or, AnySelectQuery as Ot, createTestHelpers as P, QueryValueType as Pn, defineGenericOperator as Pr, ValuesQuery as Pt, RelationDeclaration as Q, TableOptions as Qn, Ordering as Qt, DecodedFields as R, Operand as Rn, UpdateSet as Rt, DbQueryState as S, RelationRefs as Sn, AnyColumn as Sr, SelectionState as St, TransactionOptions as T, OneValueRows as Tn, KeyKind as Tr, HasEquality as Tt, AnyMutationQuery as U, AnyTableKeys as Un, NestedQuery as Ut, SqlQuery as V, CompileOptions as Vn, ExpressionValue as Vt, InitialMutationState as W, ColumnDefinitions as Wn, Selection as Wt, OneRelationKeys as X, Table as Xn, OrderTerm as Xt, NoRelations as Y, Selectable as Yn, OrderKey as Yt, Relation as Z, TableKeys as Zn, OrderTerms as Zt, AnyDb as _, not as _n, TypeOperators as _r, Tables as _t, Helper as a, PrimaryKeyValues as an, ResultRows as ar, SchemaRelations as at, DbMutationState as b, ColumnRefs as bn, TypeTransform as br, RecordQuery as bt, PatternSignature as c, WhereCondition as cn, DriverResult as cr, UsableRelation as ct, AnyExpression as d, defineFilter as dn, createStatement as dr, one as dt, asc as en, defineTable as er, RelationKey as et, BaseOperators as f, CombinedCondition as fn, AnyType as fr, AnySchema as ft, UntypedExpression as g, and as gn, TypeInput as gr, SchemaTables as gt, TypedExpression as h, Predicate as hn, Type as hr, SchemaPartRelations as ht, sql as i, NotAKey as in, ResultMode as ir, SchemaContext as it, TestHelpers as j, InitialQueryState as jn, GenericOperator as jr, ResultOf as jt, PendingTestFixture as k, CountValueType as kn, NoOperators as kr, BoundSelectQuery as kt, textOperators as l, WhereFilter as ln, SqlStatement as lr, UsedRelation as lt, ExpressionOperators as m, ConditionOperand as mn, TextValue as mr, SchemaPart as mt, identifier as n, orderBy as nn, RequiredRelationError as nr, RelationKind as nt, HelperEffect as o, EqValue as on, Connection as or, TableContext as ot, Expression as p, Condition as pn, BaseType as pr, Schema as pt, DeclaredRelations as q, ColumnValues as qn, OrderColumns as qt, param as r, KeyCheck as rn, ResultDecodeError as rr, RequiredMember as rt, defineHelper as s, WhereCallback as sn, Driver as sr, TableRelations as st, SqlTemplate as t, desc as tn, NotFoundError as tr, RelationKeys as tt, orderingOperators as u, WhereValues as un, TransactionFailure as ur, many as ut, BindOptions as v, or as vn, TypeOptions as vr, defineSchema as vt, DatabaseOptions as w, OneRow as wn, ColumnAttributes as wr, EqualityOperators as wt, DbOf as x, QueryContext as xn, defineType as xr, RecordQueryState as xt, Db as y, ExistsValueType as yn, TypeOutput as yr, AnyRecordQuery as yt, FieldTypes as z, OperandValue as zn, UpdateValues as zt };
+export { InitialSqlQueryState as $, EmptyRecord as $n, KeyKind as $r, Predicate as $t, AnyDb as A, SchemaPartRelations as An, RequiredRelationError as Ar, UpdateSet as At, TransactionCoordinator as B, MergeSelection as Bn, AnyType as Br, desc as Bt, orderingOperators as C, UsableRelation as Cn, Selectable as Cr, ScalarQuery as Ct, ExpressionOperators as D, AnySchema as Dn, ToColumns as Dr, from as Dt, Expression as E, one as En, TableOptions as Er, ValuesQuery as Et, DbQueryState as F, RecordQuery as Fn, Driver as Fr, OrderTerm as Ft, TestHooks as G, FilteredRows as Gn, TypeOperators as Gr, EqValue as Gt, PendingTestFixture as H, Selection as Hn, TextValue as Hr, KeyCheck as Ht, Database as I, RecordQueryState$1 as In, DriverResult as Ir, OrderTerms as It, AnyQuery as J, QueryResult as Jn, TypeTransform as Jr, WhereFilter as Jt, TestTransactionOptions as K, OneRow as Kn, TypeOptions as Kr, WhereCallback as Kt, DatabaseOptions as L, SelectionState as Ln, SqlStatement as Lr, Ordering as Lt, Db as M, Tables as Mn, ResultMode as Mr, OrderColumns as Mt, DbMutationState as N, defineSchema as Nn, ResultRows as Nr, OrderDirection as Nt, TypedExpression as O, Schema as On, defineTable as Or, ColumnValue as Ot, DbOf as P, AnyRecordQuery as Pn, Connection as Pr, OrderKey as Pt, FieldTypes as Q, literal as Qn, ColumnAttributes as Qr, ConditionOperand as Qt, TransactionOptions as R, ExpressionInput as Rn, TransactionFailure as Rr, SelectedRefs as Rt, NumberTypeOperators as S, TableRelations as Sn, KeyColumns as Sr, ResultOf as St, BaseOperators as T, many as Tn, TableKeys as Tr, TypedScalarQuery as Tt, TestFixture as U, SelectionResult as Un, Type as Ur, NotAKey as Ut, OpenedTestFixture as V, NestedQuery as Vn, BaseType as Vr, orderBy as Vt, TestHelpers as W, SelectionUses as Wn, TypeInput as Wr, PrimaryKeyValues as Wt, AnySqlQuery as X, ValueRows as Xn, AnyColumn as Xr, CombinedCondition as Xt, SelectQueryKind as Y, ResultByRows as Yn, defineType as Yr, WhereValues as Yt, DecodedFields as Z, Literal as Zn, Column as Zr, Condition as Zt, TextConversionSignature as _, RelationKind as _n, AnyTableKeys as _r, least as _t, Helper as a, GenericOperator as ai, QueryContext as an, EqualityOperator as ar, MutationQueryState as at, TextTypeOperators as b, SchemaRelations as bn, ColumnShape as br, FilteredStateRows as bt, ColumnRefKey as c, defineGenericOperator as ci, DeclaredRelations as cn, InSignature as cr, CaseValue as ct, NotAColumn as d, OneRelationKeys as dn, ComparisonSignature as dr, TypedOperand as dt, ToColumn as ei, and as en, InitialQueryState as er, SqlQuery as et, matches as f, Relation as fn, Operand as fr, TypedOperandInput as ft, PatternSignature as g, RelationKeys as gn, AnyTable as gr, greatest as gt, TRUE as h, RelationKey as hn, CompileOptions as hr, coalesce as ht, sql as i, OperatorDefinitions as ii, ColumnRefs as in, SelectQueryState as ir, MutationQuery as it, BindOptions as j, SchemaTables as jn, ResultDecodeError as jr, UpdateValues as jt, UntypedExpression as k, SchemaPart as kn, NotFoundError as kr, InsertValues as kt, MatchCheck as l, MergeRelations as ln, equalityOperators as lr, FollowingOperand as lt, FALSE as m, RelationDeclarations as mn, compare as mr, caseWhen as mt, identifier as n, MergeOperators as ni, or as nn, QueryStateOf as nr, AnyMutationQuery as nt, HelperEffect as o, GenericOperatorImplementation as oi, RelationRefs as on, EqualityOperators as or, CaseBranch as ot, defineExpression as p, RelationDeclaration as pn, OperandValue as pr, TypedOperandOperators as pt, createTestHelpers as q, OneValueRows as qn, TypeOutput as qr, WhereCondition as qt, param as r, NoOperators as ri, ExistsValueType as rn, QueryValueType as rr, InitialMutationState as rt, defineHelper as s, OperatorSignature as si, CountValueType as sn, HasEquality as sr, CaseCondition as st, SqlTemplate as t, BoundOperators as ti, not as tn, QueryState as tr, SqlQueryState as tt, MatchResult as u, NoRelations as un, BooleanResult as ur, NullSkippingResult as ut, TextLengthSignature as v, RequiredMember as vn, ColumnDefinitions as vr, AnySelectQuery as vt, AnyExpression as w, UsedRelation as wn, Table as wr, SelectQuery as wt, textOperators as x, TableContext as xn, ColumnValues as xr, OperandUses as xt, TextOperators as y, SchemaContext as yn, ColumnOperators as yr, BoundSelectQuery as yt, createDatabase as z, ExpressionValue as zn, createStatement as zr, asc as zt };