kern-orm 0.4.0 → 0.6.0

package/dist/{index--0tyG7sU.d.mts → index-CoKpXcBp.d.mts}

@@ -209,9 +209,9 @@ 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. */
-  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`. */
+  /** 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`; `null` for a statement that PostgreSQL completes without a tag, such as an empty text or only a comment. */
+  readonly command: string | null;
+  /** Number of rows that the command tag reports, such as the rows that an `UPDATE` changes, also without `RETURNING`; `0` when PostgreSQL reports none, such as for `BEGIN` or a statement without a command tag. */
   readonly count: number;
   /** Names of the result columns in their order, also when the statement returns no rows; none for a statement without result columns, such as `BEGIN` or an `UPDATE` without `RETURNING`. */
   readonly columns: readonly string[];
@@ -278,6 +278,13 @@ interface RecordTemplateField {
   readonly key: string;
   readonly value: unknown;
 }
+/** How code converts the decoded result of a query, by `map` and `transform` of the query: `map` runs before `transform`, since `map` does not apply after `transform`. */
+interface ResultConversion {
+  /** Converts each record or value, also `null` of a `NULL` value, and is not called for a missing row. */
+  readonly map: ((row: unknown) => unknown) | undefined;
+  /** Converts the whole result, once: an array of rows, one row, or `null` or `undefined` of a missing row. */
+  readonly transform: ((result: unknown) => unknown) | undefined;
+}
 /**
  * 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.
  *
@@ -303,6 +310,8 @@ interface ResultPlan extends ResultMode {
    * A record starts from it, so its keys keep their order whichever of them a row holds.
    */
   readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
+  /** How code converts the result that the plan decodes; `undefined` for a query without `transform` and `map`. */
+  readonly conversion?: ResultConversion | 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 {
@@ -328,13 +337,23 @@ declare class RequiredRelationError extends Error {
   /** Path of the field of the relation from the result field that holds it, such as `fields[2].form`, after the index of the row of an executed query of rows `many`, such as `[2].form`. */
   path: string);
 }
-/** Error thrown when a row does not match the result fields or a value fails to decode; the failure of the value is its cause. */
+/** Error thrown when a row does not match the result fields, a value fails to decode, or a callback of `transform` or `map` fails; the failure is its cause. */
 declare class ResultDecodeError extends Error {
-  /** Path of the value from its result field, such as `fields[2].label`, after the index of the row of an executed query of rows `many`, such as `[2].label`; `undefined` for a row of the driver of another width than the result fields. */
+  /**
+   * Path of the value from its result field, such as `fields[2].label`, after the index of the row of an executed query of rows `many`, such as `[2].label`.
+   *
+   * A callback of `map` that fails has the path of its row, such as `fields[2]` or `[2]`, and one of `transform` the path of the field of its nested rows, such as `fields`.
+   * It is `undefined` for a row of the driver of another width than the result fields, and for a callback that fails on the only row or the whole result of an executed query.
+   */
   readonly path: string | undefined;
   readonly name = "ResultDecodeError";
   constructor(message: string,
-  /** Path of the value from its result field, such as `fields[2].label`, after the index of the row of an executed query of rows `many`, such as `[2].label`; `undefined` for a row of the driver of another width than the result fields. */
+  /**
+   * Path of the value from its result field, such as `fields[2].label`, after the index of the row of an executed query of rows `many`, such as `[2].label`.
+   *
+   * A callback of `map` that fails has the path of its row, such as `fields[2]` or `[2]`, and one of `transform` the path of the field of its nested rows, such as `fields`.
+   * It is `undefined` for a row of the driver of another width than the result fields, and for a callback that fails on the only row or the whole result of an executed query.
+   */
   path: string | undefined, options?: ErrorOptions);
 }
 /** Tells whether `T` is `any`: only `any` turns `1 & T` into a type that `0` extends. */
@@ -390,6 +409,11 @@ interface TableOptions<Column extends string = string, PrimaryKeyColumn extends
   /** Unique keys of several columns; mark a unique key of one column with `unique()`. */
   readonly unique?: readonly (readonly [Column, Column, ...Column[]])[];
 }
+/** Options of `createTableFactory`. */
+interface TableFactoryOptions {
+  /** Returns the physical name of a column from its key, such as `toSnakeCase` does, for each column without an explicit `columnName()`. */
+  readonly columnName: (key: string) => string;
+}
 /** Record shape returned when all columns of a table are selected. */
 type Selectable<T extends AnyTable> = { [K in keyof T["columns"]]: TypeOutput<T["columns"][K]["type"]>; };
 /** Input values of the types of the columns. */
@@ -462,10 +486,123 @@ declare function defineTable<Name extends string, Definitions extends ColumnDefi
  * A key of one column is marked on its column, and `options` list the columns of the keys of several columns.
  */
 declare function defineTable<Name extends string, Definitions extends ColumnDefinitions, const Options extends TableOptions<ColumnKey<ToColumns<Definitions>>, PrimaryKeyOption<ToColumns<Definitions>>> | undefined>(name: Name, definitions: Definitions, options: Options): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, Options>>;
-/** Physical placement of the tables of a query, fixed at compilation. */
-interface CompileOptions {
-  /** PostgreSQL schema qualifying every table; tables stay unqualified when it is not set. */
-  schemaName?: string;
+/**
+ * Creates a table-definition function with the given naming convention, for an application to define its tables with.
+ *
+ * Its tables have the same types as those of `defineTable`.
+ */
+declare function createTableFactory(factoryOptions: TableFactoryOptions): typeof defineTable;
+/** 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 {
+  /** 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`, or what the callback of `map` or `transform` returns. */
+  readonly result: unknown;
+  /** How the rows become the result. */
+  readonly rows: ResultRows;
+  /**
+   * What a row is: a record for `false`, the value of its only field for `true`, or what a callback of code returns: of `map` for `"mapped"`, whichever the row was before it, or of `transform` for `"transformed"`, of the whole result.
+   *
+   * The states of the methods that read the fields of a row or the value of its only field narrow it to `false` or `true`, so that they reject a query that code converts.
+   */
+  readonly value: boolean | "mapped" | "transformed";
+  /** 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, the type of its value or the types of its fields, 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;
+  /** Types of the values of the selected fields of a query of records, the values that each encodes and its operators, which the callback of `having` gives its references: a `SelectedFieldTypes`, or `EmptyRecord` without selected fields. */
+  readonly fieldTypes: 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`, or converted by `map`, 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 fieldTypes: EmptyRecord;
+  readonly rows: Rows;
+  readonly value: false;
+  readonly uses: U;
+  readonly guaranteed: Guaranteed;
+  readonly aggregate: false;
+}
+/** Mark of `aggregate: false` of a query of groups, which aggregate methods replace. */
+interface Grouped {
+  readonly grouped: true;
+}
+/** Key of the value of a query in an expression, for types only. */
+declare const scalarValue: unique symbol;
+/** Value of a query of state `S` in an expression: its value, or `NULL` without its row unless the query always has it. */
+type ScalarValue<S extends SelectQueryState> = S["aggregate"] extends true ? S["result"] : S["guaranteed"] extends true ? S["result"] : S["result"] | null;
+/**
+ * Query of one value of a table, such as of `get`, of an aggregate, or of `exists`, which an expression takes as a scalar subquery of its value, or as `EXISTS` of the rows of a query of `exists`.
+ *
+ * `T` is its value there: without its row, a query of `get` is `NULL`, unless a required relation guarantees the row, such as of `field.form`.
+ */
+interface ScalarQuery<T = unknown> {
+  /** Value of the query in an expression, from which an expression infers `T`. */
+  readonly [scalarValue]: T;
+  readonly types: ScalarQueryState;
+  readonly exists: 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";
+  readonly value: true;
+}
+/** State of a query of one value with the type of its value, whose expression `expr` gives. */
+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>;
+  readonly exists: unknown;
+}
+/** Value of query `Q` of values, of each of its rows. */
+type ValuesQueryValue<Q extends ValuesQuery> = Q["types"]["result"];
+/** State of a query of values whose value is `T`. */
+interface ValuesQueryState<T> extends SelectQueryState {
+  readonly result: T;
+  readonly value: true;
 }
 /**
  * Value compared with an expression of type `T` accepting values of type `I`: a value, an expression, or a query of one value, such as of `get` or of an aggregate; `null` is matched with `isNull` instead.
@@ -485,6 +622,39 @@ 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;
+/** Physical placement of the tables of a query, fixed at compilation. */
+interface CompileOptions {
+  /** PostgreSQL schema qualifying every table; tables stay unqualified when it is not set. */
+  schemaName?: string;
+}
 /** Selection of the rows of a nested query as the value of the field `key`. */
 interface NestedSelectionNode {
   readonly key: string;
@@ -510,13 +680,31 @@ interface QueryNode extends ResultMode {
   /** Fields in the order of the result, with unique keys; a query without them returns records without fields. */
   readonly projections: readonly SelectedNode[];
   readonly filters: QueryFilters;
+  /** Keys of the groups of the rows; a query with them gives one row of each group. */
+  readonly groupBy: readonly ExpressionNode[];
+  /** Condition of the groups, apart from `filters`, which choose the rows that they group. */
+  readonly having: ExpressionNode | undefined;
   readonly orderBy: readonly OrderNode[];
   readonly limit: ExpressionNode | undefined;
   readonly offset: ExpressionNode | undefined;
+  /** Whether `distinct` removes the duplicates of the rows, comparing the fields that the query selects when it compiles. */
+  readonly distinct: boolean;
+  /** Keys of `distinctOn`, whose equal values give one row, the first in the order of the query; none without `distinctOn`. */
+  readonly distinctOn: readonly ExpressionNode[];
+  /**
+   * Fields of a query of `distinct` or `distinctOn` that an aggregate method or `exists` replaced, or `undefined` otherwise.
+   *
+   * `distinct` compares them, and the keys, the order, and the argument of the aggregate read a selected field through its projection.
+   */
+  readonly distinctFields: readonly SelectedNode[] | undefined;
+  /** Lock of the rows that the query reads. */
+  readonly lock: RowLockNode | undefined;
   /** Whether a required relation guarantees the row of the query, so that a filter makes a query of rows `one` resolve without it; see `SelectQueryState`. */
   readonly guaranteed: boolean;
   /** Whether `all` allows a mutation of the query to change every row of the table without a filter. */
   readonly all: boolean;
+  /** How `map` and `transform` convert the decoded result. */
+  readonly conversion: ResultConversion | undefined;
 }
 /**
  * Mutation of a table that returns the fields of the rows it changes, which may nest queries, or the number of the rows without them.
@@ -530,68 +718,15 @@ interface RecordQueryNode {
   /** 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;
-}
-/** 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;
-}
 /** 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 {
@@ -600,8 +735,8 @@ interface CountValueType extends QueryValueType {
 }
 /** 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 a filter of a query whose row a required relation guarantees: `one` becomes `nullable`, or `optional` for a query of values that `map` does not convert; other modes stay. */
+type FilteredRows<Rows extends ResultRows, Value> = 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. */
@@ -616,23 +751,6 @@ type OneValueRows<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows
 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.
- *
- * 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.
- */
-type RelationRefs<C extends SchemaContext> = string extends C["key"] ? EmptyRecord : C["key"] extends keyof C["relations"] ? RelationQueries<C["relations"], C["key"]> : EmptyRecord;
-type RelationQueries<R extends SchemaContext["relations"], K extends keyof R & string> = { readonly [N in keyof R[K]]: RelatedQuery<R, K, N & string>; };
-/** Unbound query of the records of relation `N` of the table under key `K` of a schema of relations `R`, in the schema context of its target and the rows mode of the relation, whose row a required relation guarantees. */
-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. */
-  readonly relations: PropertyDescriptorMap;
-}
 /** Type of the value of a query of `exists`. */
 interface ExistsValueType extends QueryValueType {
   readonly input: boolean;
@@ -686,20 +804,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.
+ * 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.
  *
- * The condition can be combined further with `and`, `or`, and `not`.
+ * 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, since a general alias that takes the filter as an argument resolves it on every call.
  */
-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.
- *
- * 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.
- */
-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.
  *
@@ -716,100 +826,42 @@ type KeyCheck<T extends AnyTable, Columns> = [IsKey<T, Columns>] extends [true]
 interface NotAKey<Keys> {
   readonly "columns must be exactly one key of the table": Keys;
 }
+/** Key of a group returned by the callback of `groupBy` or `distinctOn`: an expression or a query of one value, such as of a value of a related record. */
+type GroupTerm = AnyExpression | ScalarQuery;
+/** Keys of a group returned by the callback of `groupBy` or `distinctOn`: one or an array of them. */
+type GroupTerms = GroupTerm | readonly GroupTerm[];
 /**
- * Direction of a sort key, optionally with the placement of `NULL`.
+ * What the callback of `having` of a query of state `S` receives as its second parameter: the references to the selected fields of a query of records, with the operators and the values of the types of their fields, the expression of the value of a query made by `get` or `pluck`, and `undefined` for an aggregate query, a query of `exists`, and a query that `map` converts.
  *
- * Without a placement, `NULL` comes last in ascending order and first in descending order.
+ * A field of nested rows or of a literal is among the references, but reading it throws; a field of the rows of a query of one value, such as of `get`, has the operators of its value in types.
  */
-type OrderDirection = "asc" | "desc" | "asc nulls first" | "asc nulls last" | "desc nulls first" | "desc nulls last";
-/** Columns of table `T` with the directions to sort by them, in the order of their keys. */
-type OrderColumns<T extends AnyTable> = { readonly [K in keyof T["columns"]]?: OrderDirection; };
-/** Argument of `orderBy` of a query over table `T`: a column key, sorted in ascending order, or columns with directions. */
-type OrderKey<T extends AnyTable> = (keyof T["columns"] & string) | OrderColumns<T>;
-declare const ordering: unique symbol;
-/** Expression or query of one value with the direction of its sort key, made by `asc`, `desc`, or `orderBy`. */
-interface Ordering {
-  readonly [ordering]: true;
-}
-/** Sort key returned by the callback of `orderBy`: an expression or a query of one value, such as of an aggregate of related records, sorted in ascending order, or one with a direction. */
-type OrderTerm = AnyExpression | ScalarQuery | Ordering;
+type HavingFields<S extends SelectQueryState> = S["value"] extends false ? { readonly [K in keyof S["result"] & string]: FieldRef<SelectedFieldTypesOf<S["fieldTypes"]>, K, S["result"][K]>; } : S["value"] extends true ? S["aggregate"] extends false ? ToFieldRef<S["valueType"], S["result"]> : undefined : undefined;
+/** Reference of the callback of `having` to field `K` of values `V`, with the type of its value among field types `F`, for each member of a union of them. */
+type FieldRef<F, K extends string, V> = K extends keyof F ? ToFieldRef<Exclude<F[K], undefined>, V> : AnyExpression<V>;
+/** Expression of values `V` with the operators and the values of type `D` of a value, or without them when `D` is none. */
+type ToFieldRef<D, V> = D extends QueryValueType ? D extends {
+  readonly group: infer G;
+} ? unknown extends G ? Expression<V, D["operators"], D["input"]> // References can escape this callback and be selected without grouping, so retain standalone nullability and the group mark.
+ : Expression<V | null, D["operators"], D["input"]> & GroupValue<G> : Expression<V, D["operators"], D["input"]> : AnyExpression<V>;
 /**
- * References of the callback of `orderBy` to the fields of records `R` selected by a query: their expressions by key.
+ * Argument of `having` of a query of state `S`: a condition of `where`, or a callback that receives the columns and the relations of the table, and the fields of `HavingFields`, and returns one.
  *
- * 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.
+ * It reads `S` only in its branch, as `QueryWhereFilter` does.
  */
-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. */
-type OrderTerms = OrderTerm | readonly OrderTerm[];
-/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
-declare function asc(value: AnyExpression | ScalarQuery): Ordering;
-/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
-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;
+type QueryHavingFilter<S extends SelectQueryState> = [S] extends [unknown] ? WhereCondition<S["table"]> | ((columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>, selected: HavingFields<S>) => WhereCondition<S["table"]>) : never;
 /**
- * Field of a selection whose value is `T`, made by `literal`.
+ * What a query with a row lock does with a row that another transaction has locked, instead of waiting for it:
  *
- * It is not an expression: it has no SQL, so only a selection takes it.
+ * - `skipLocked` leaves the row out of its result, such as to take the next free job of a queue.
+ * - `noWait` rejects with a PostgreSQL error of SQLSTATE `55P03`.
  */
-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>;
-/** 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]; }>;
-/** 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]>;
-/** 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>);
-/** 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]; } & {};
+type RowLockOptions = {
+  readonly noWait?: boolean;
+  readonly skipLocked?: false;
+} | {
+  readonly noWait?: false;
+  readonly skipLocked?: boolean;
+};
 /** 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. */
 type FilteredStateRows<S extends SelectQueryState> = [S["guaranteed"]] extends [false] ? S["rows"] : [S["value"]] extends [false] ? S["result"] extends HelperFields ? S["rows"] : FilteredRows<S["rows"], false> : FilteredRows<S["rows"], S["value"]>;
 /** State `S` after a filter, which ends the guarantee of its row. */
@@ -822,49 +874,6 @@ type FoundState<S extends SelectQueryState> = ChangeState<S, {
   rows: OneRow<FilteredStateRows<S>>;
   guaranteed: false;
 }>;
-/** Query of state `S`, bound or unbound. */
-type QueryOf<S extends SelectQueryState> = SelectQuery<S, SelectQueryKind>;
-declare const scalarValue: unique symbol;
-/** Value of a query of state `S` in an expression: its value, or `NULL` without its row unless the query always has it. */
-type ScalarValue<S extends SelectQueryState> = S["aggregate"] extends true ? S["result"] : S["guaranteed"] extends true ? S["result"] : S["result"] | null;
-/**
- * Query of one value of a table, such as of `get`, of an aggregate, or of `exists`, which an expression takes as a scalar subquery of its value, or as `EXISTS` of the rows of a query of `exists`.
- *
- * `T` is its value there: without its row, a query of `get` is `NULL`, unless a required relation guarantees the row, such as of `field.form`.
- */
-interface ScalarQuery<T = unknown> {
-  /** Value of the query in an expression, from which an expression infers `T`. */
-  readonly [scalarValue]: T;
-  readonly types: ScalarQueryState;
-  readonly exists: unknown;
-}
-/** Value of query `Q` of one value in an expression. */
-type ScalarQueryValue<Q extends ScalarQuery> = Q[typeof scalarValue];
-/** State of a query of one value, which an expression takes. */
-interface ScalarQueryState extends SelectQueryState {
-  readonly rows: "one" | "optional";
-  readonly value: true;
-}
-/** State of a query of one value with the type of its value, whose expression `expr` gives. */
-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>;
-  readonly exists: unknown;
-}
-/** Value of query `Q` of values, of each of its rows. */
-type ValuesQueryValue<Q extends ValuesQuery> = Q["types"]["result"];
-/** State of a query of values whose value is `T`. */
-interface ValuesQueryState<T> extends SelectQueryState {
-  readonly result: T;
-  readonly value: true;
-}
 /** State of a query whose rows are records, which `select` and `clearSelect` change. */
 type RecordQueryState$1 = SelectQueryState & {
   readonly value: false;
@@ -877,26 +886,53 @@ type UnguaranteedQueryState = SelectQueryState & {
 type ValueQueryState = SelectQueryState & {
   readonly value: true;
 };
+/** State of a query converted by `map`, whose callback of `orderBy` reads no selected fields, which its result no longer tells. */
+type MappedQueryState = SelectQueryState & {
+  readonly value: "mapped";
+};
 /** State of a query of values with the values that the type of its value encodes, which `coalesce` takes; it narrows nothing else, so that a call compares no operators. */
 type CoalesceQueryState = ValueQueryState & {
   readonly valueType: {
     readonly input: unknown;
   };
 };
-/** State of a query not made by an aggregate method or `exists`, which `get`, `pluck`, the aggregate methods, and `exists` apply to. */
+/** State of a query not made by an aggregate method or `exists`, which `get`, `pluck`, the aggregate methods, `exists`, and `groupBy` apply to. */
 type UnaggregatedQueryState = SelectQueryState & {
   readonly aggregate: false;
 };
+/** State of a query of values not made by an aggregate method or `exists`, such as of `pluck`, whose callback of `groupBy` reads its value. */
+type UnaggregatedValueQueryState = ValueQueryState & UnaggregatedQueryState;
 /** Type of the value of a query of column `K` of table `T`. */
 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 `S` after grouping, with the values of its directly selected aggregates in nonempty groups. */
+interface GroupedState<S extends SelectQueryState> extends SelectQueryState {
+  readonly table: S["table"];
+  readonly schema: S["schema"];
+  readonly result: GroupedResult<S>;
+  readonly rows: S["rows"];
+  readonly value: S["value"];
+  readonly valueType: S["valueType"];
+  readonly fieldTypes: S["fieldTypes"];
+  readonly uses: S["uses"];
+  readonly guaranteed: S["guaranteed"];
+  readonly aggregate: false & Grouped;
+}
+/** Selected result after grouping, retaining the records or scalar value of the query. */
+type GroupedResult<S extends SelectQueryState> = S["value"] extends false ? S["fieldTypes"] extends SelectedFieldTypes<unknown, unknown> ? GroupedRecord<S["result"], S["fieldTypes"]["types"]> : S["result"] : S["value"] extends true ? GroupedField<S["result"], S["valueType"]> : S["result"];
+/** Type of a selected operand, carrying its value in a group for a later call of `groupBy`. */
+interface SelectedOperandType<E extends TypedOperand> extends QueryValueType {
+  readonly input: TypedOperandInput<E>;
+  readonly operators: TypedOperandOperators<E>;
+  readonly group: E extends GroupValue<infer V> ? V : unknown;
+}
 /** 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, {
   result: V;
@@ -906,26 +942,60 @@ 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. */
 type ManyRowsQueryState = SelectQueryState & {
   readonly rows: "many";
 };
+/** State of a query that returns rows of its table, which a row lock applies to: not of an aggregate or of `exists`. */
+type LockableQueryState = SelectQueryState & ({
+  readonly aggregate: false;
+} | {
+  readonly value: "mapped";
+});
 /** State of a query of one row, which `optional` and `required` apply to. */
 type OneRowQueryState = SelectQueryState & {
   readonly rows: "one" | "nullable" | "optional";
 };
-/** State of a query of one row whose rows are records, which `nullable` applies to. */
+/** State of a query of one row whose rows are records or what `map` gives, which `nullable` applies to. */
 type OneRecordQueryState = OneRowQueryState & {
-  readonly value: false;
+  readonly value: false | "mapped";
 };
+/**
+ * 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` 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]; } & {};
+/** Query of state `S`, bound or unbound. */
+type QueryOf<S extends SelectQueryState> = SelectQuery<S, SelectQueryKind>;
 /**
  * Immutable select query of state `S`, unbound or bound to a `Db`.
  *
@@ -936,7 +1006,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. */
@@ -946,23 +1016,25 @@ 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, {
     result: MergeSelection<S["result"], Selectable<S["table"]>>;
+    fieldTypes: SelectedFieldTypes<S["fieldTypes"], ColumnFieldTypes<S["table"], keyof S["table"]["columns"]>>;
   }>, 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, {
     result: MergeSelection<S["result"], Pick<Selectable<S["table"]>, K>>;
+    fieldTypes: SelectedFieldTypes<S["fieldTypes"], ColumnFieldTypes<S["table"], K>>;
   }>, Kind>;
   /**
    * Selects the expressions and nested queries returned by `callback`, replacing fields under their keys.
@@ -972,12 +1044,14 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * 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, {
-    result: MergeSelection<S["result"], SelectionResult<Sel>>;
+    result: MergeSelection<S["result"], S["aggregate"] extends Grouped ? GroupSelectionResult<Sel> : SelectionResult<Sel>>;
     uses: S["uses"] | SelectionUses<Sel>;
+    fieldTypes: SelectedFieldTypes<S["fieldTypes"], SelectionFieldTypes<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, {
     result: EmptyRecord;
+    fieldTypes: EmptyRecord;
   }>, Kind>;
   /**
    * Limits the query to one row and returns the row instead of an array; without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
@@ -1018,15 +1092,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: S["aggregate"] extends Grouped ? GroupOperandValue<E> : OperandValue<E>;
+    valueType: SelectedOperandType<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.
@@ -1042,60 +1119,99 @@ 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: S["aggregate"] extends Grouped ? GroupOperandValue<E> : OperandValue<E>;
+    valueType: SelectedOperandType<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.
    *
-   * It keeps the filters and ignores the order; with `limit` or `offset`, it counts the rows of that page.
+   * It keeps the filters and ignores the order; with `limit` or `offset`, it counts the rows of that page, after `groupBy`, the groups, after `distinct`, the distinct rows of the selected fields, and after `distinctOn`, the first rows.
    */
   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`.
    *
-   * It keeps the filters, the limit, and the offset, and ignores the order.
+   * It keeps the filters, the limit, and the offset, and ignores the order; after `groupBy`, it tells whether the query has a group, and after `distinct` and `distinctOn`, it checks the distinct rows and the first rows.
    */
   exists<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<AggregateState<S, boolean, ExistsValueType>, Kind>;
   /**
@@ -1106,6 +1222,9 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   coalesce<S extends CoalesceQueryState, Kind extends SelectQueryKind, F extends Operand<S["result"], S["valueType"]["input"]>>(this: SelectQuery<S, Kind>, fallback: F): SelectQuery<ChangeState<S, {
     result: CoalescedValue<S["result"], F>;
+    valueType: S["valueType"] extends {
+      readonly group: unknown;
+    } ? Omit<S["valueType"], "group"> : S["valueType"];
   }>, Kind>;
   /**
    * Returns an expression of the value of a query of one value, such as of `get` or of an aggregate, with the operators of its type, such as `form.fields.count().expr().gt(3)`.
@@ -1113,6 +1232,36 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Without a row, the expression is `NULL`, and the query does not reject.
    */
   expr<Q extends QueryOf<ExpressionQueryState>>(this: Q): Expression<ScalarQueryValue<Q>, Q["types"]["valueType"]["operators"], Q["types"]["valueType"]["input"]>;
+  /** Groups the rows by the listed columns, after the keys of earlier calls, so that the query gives one row of each group, whose fields are its keys and the aggregates of its rows, such as `sum(field.position)`. */
+  groupBy<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...keys: (keyof S["table"]["columns"] & string)[]): SelectQuery<GroupedState<S>, Kind>;
+  /**
+   * Groups the rows by the keys returned by `callback`, after the keys of earlier calls, so that the query gives one row of each group, whose fields are its keys and the aggregates of its rows, such as `sum(field.position)`.
+   *
+   * `callback` receives the columns with the queries of the relations of the table, and the fields selected so far, and returns an expression or a query of one value, or an array of them.
+   * A selected field groups by the value of the field; a field of nested rows or of a literal cannot be grouped by.
+   * Methods that choose rows and read values, such as `limit`, `take`, and `pluck`, apply to the groups, and an aggregate method aggregates them, such as `count` for the number of the groups.
+   * The query cannot take a row lock, `update`, or `delete`.
+   */
+  groupBy<S extends RecordQueryState$1, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>, selected: SelectedRefs<S["result"]>) => GroupTerms): SelectQuery<GroupedState<S>, Kind>;
+  /**
+   * Groups the rows of a query made by `get` or `pluck` by the keys returned by `callback`, after the keys of earlier calls.
+   *
+   * `callback` receives the columns with the queries of the relations of the table, and the expression of the value, and returns what `groupBy` of a query of records takes.
+   */
+  groupBy<S extends UnaggregatedValueQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>, value: AnyExpression<S["result"]>) => GroupTerms): SelectQuery<GroupedState<S>, Kind>;
+  /**
+   * Filters the groups of a query of `groupBy` by what `where` takes, such as an aggregate of a group, combined with `AND` with the previous conditions of the groups; `where` keeps filtering the rows of the groups.
+   *
+   * A callback also receives the fields selected so far, such as `having((submission, selected) => selected.submissions.gt(1))`, or the value of a query made by `get` or `pluck`.
+   */
+  having<Q extends QueryOf<UnguaranteedQueryState>>(this: Q, filter: QueryHavingFilter<Q["types"]>): Q;
+  /**
+   * Filters the groups of a query of `groupBy` by what `where` takes, such as an aggregate of a group, combined with `AND` with the previous conditions of the groups; `where` keeps filtering the rows of the groups.
+   *
+   * A callback also receives the fields selected so far, or the value of a query made by `get` or `pluck`.
+   * A query of the record of a required relation, such as `field.form`, resolves to `null` without a group that passes the filter, or to `undefined` after `get` or `pluck`.
+   */
+  having<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, filter: QueryHavingFilter<S>): SelectQuery<FilteredState<S>, Kind>;
   /**
    * Sorts the rows by the sort keys returned by `callback`, after the sort keys of earlier calls.
    *
@@ -1128,12 +1277,73 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It returns an expression or a query of one value, sorted in ascending order, `asc`, `desc`, or `orderBy` of one, or an array of them.
    */
   orderBy<Q extends QueryOf<ValueQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, value: AnyExpression<Q["types"]["result"]>) => OrderTerms): Q;
+  /**
+   * Sorts the rows of a query that `map` converts by the sort keys returned by `callback`, after the sort keys of earlier calls.
+   *
+   * `callback` receives the columns with the queries of the relations of the table, and returns what `orderBy` of a query of records takes.
+   */
+  orderBy<Q extends QueryOf<MappedQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>) => OrderTerms): Q;
   /** Sorts the rows by the listed columns in ascending order, or in the directions of objects of columns, after the sort keys of earlier calls. */
   orderBy<Q extends AnySelectQuery>(this: Q, ...keys: OrderKey<Q["types"]["table"]>[]): Q;
   /** Returns at most `count` rows of a query of many rows, replacing an earlier limit. */
   limit<Q extends QueryOf<ManyRowsQueryState>>(this: Q, count: number): Q;
   /** Skips the first `count` rows of a query of many rows, replacing an earlier offset. */
   offset<Q extends QueryOf<ManyRowsQueryState>>(this: Q, count: number): Q;
+  /**
+   * Removes the duplicate rows of a query of many rows, such as of `pluck` for `in`, comparing the fields that the query selects, also those selected after it.
+   *
+   * Sort the query only by its selected fields.
+   * The query cannot select nested rows, which `distinct` cannot compare.
+   * The aggregate methods and `exists` after it read the distinct rows of the fields selected before them, and an aggregate method takes only a selected column or expression.
+   */
+  distinct<Q extends QueryOf<ManyRowsQueryState>>(this: Q): Q;
+  /**
+   * Keeps the first row of each group of the rows of a query of many rows with equal values of the keys returned by `callback`, after the keys of earlier calls, such as the latest submission of each user.
+   *
+   * `callback` receives the columns with the queries of the relations of the table, and the fields selected so far, and returns an expression or a query of one value, or an array of them; a field of nested rows or of a literal cannot be a key.
+   * Sort the query by the keys first, then by the order that chooses the first row of each group; the rows keep that order.
+   * To sort by a key of an expression, select it and take it from the second parameter of the callbacks of `distinctOn` and `orderBy`.
+   * The aggregate methods and `exists` after it read the first rows, such as `count` for the number of the groups.
+   */
+  distinctOn<Q extends QueryOf<RecordQueryState$1 & ManyRowsQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, selected: SelectedRefs<Q["types"]["result"]>) => GroupTerms): Q;
+  /**
+   * Keeps the first value of each group of the values of a query made by `pluck` with equal values of the keys returned by `callback`, after the keys of earlier calls.
+   *
+   * `callback` receives the columns with the queries of the relations of the table, and the expression of the value, and returns what `distinctOn` of a query of records takes.
+   */
+  distinctOn<Q extends QueryOf<ValueQueryState & ManyRowsQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, value: AnyExpression<Q["types"]["result"]>) => GroupTerms): Q;
+  /**
+   * Keeps the first row of each group of the rows of a query that `map` converts with equal values of the keys returned by `callback`, after the keys of earlier calls.
+   *
+   * `callback` receives the columns with the queries of the relations of the table, and returns what `distinctOn` of a query of records takes.
+   */
+  distinctOn<Q extends QueryOf<MappedQueryState & ManyRowsQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>) => GroupTerms): Q;
+  /**
+   * Keeps the first row of each group of the rows of a query of many rows with equal values of the listed columns, after the keys of earlier calls, such as the latest submission of each user.
+   *
+   * Sort the query by the keys first, then by the order that chooses the first row of each group; the rows keep that order.
+   */
+  distinctOn<Q extends QueryOf<ManyRowsQueryState>>(this: Q, ...keys: (keyof Q["types"]["table"]["columns"] & string)[]): Q;
+  /**
+   * Locks the rows of the query until its transaction ends, so that code can read a row and then update it based on the values it read: another transaction waits to change or lock them.
+   *
+   * It replaces an earlier lock of the query, and reaches no other query: lock the records of a nested query by calling it there.
+   * Without `options`, the query waits for the rows that another transaction has locked.
+   *
+   * It requires a transaction, unless the query is part of a mutation, such as of its filter.
+   * The query cannot use `distinct`, `distinctOn`, or `groupBy`, and the aggregate methods and `exists` reject it after the lock.
+   */
+  forUpdate<Q extends QueryOf<LockableQueryState>>(this: Q, options?: RowLockOptions): Q;
+  /**
+   * Locks the rows of the query as `forUpdate` does, but lets other transactions insert records that refer to them.
+   *
+   * Use it when the transaction only updates columns outside the keys of the rows.
+   */
+  forNoKeyUpdate<Q extends QueryOf<LockableQueryState>>(this: Q, options?: RowLockOptions): Q;
+  /** Keeps the rows of the query from changing until its transaction ends, as `forUpdate` does, while other transactions read and share-lock them too. */
+  forShare<Q extends QueryOf<LockableQueryState>>(this: Q, options?: RowLockOptions): Q;
+  /** Keeps the rows of the query from being deleted or changing their keys until its transaction ends, as `forUpdate` does, while other transactions change their other columns. */
+  forKeyShare<Q extends QueryOf<LockableQueryState>>(this: Q, options?: RowLockOptions): Q;
   /** Makes a query of one row, such as one of `take` or `get`, resolve to `undefined` without a row. */
   optional<S extends OneRowQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
     rows: "optional";
@@ -1142,7 +1352,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /**
    * Makes a query of one record, such as one of `take`, resolve to `null` without a row.
    *
-   * A value of `get` or `pluck` is never `null` for a missing row, which would read as a `NULL` value, so a query of values does not accept it, and after `get` or `pluck` the query resolves to `undefined` without a row.
+   * A value of `get` or `pluck` is never `null` for a missing row, which would read as a `NULL` value, so a query of values does not accept it, unless `map` converts them, and after `get` or `pluck` the query resolves to `undefined` without a row.
    */
   nullable<S extends OneRecordQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
     rows: "nullable";
@@ -1157,7 +1367,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>;
@@ -1168,15 +1378,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.
    *
@@ -1187,6 +1408,26 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   delete<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
   /** Allows `update` and `delete` to change every row of the table when the query has no filter; it changes nothing else. */
   all<Q extends QueryOf<ManyRowsQueryState>>(this: Q): Q;
+  /**
+   * Converts each record or value of the result in code, after decoding, executed or nested, such as to add a field that SQL cannot compute.
+   *
+   * `callback` receives one record or value, also `null` of a `NULL` value, and is not called for a missing row, so an optional query still resolves to `undefined` without a row; it returns its result synchronously.
+   * The SQL stays as it is, so the methods that read the fields, such as `select` and `count`, and expressions reject the query after it, whereas `where`, `orderBy`, `limit`, `take`, and further `map` apply.
+   * A failure of `callback` rejects with `ResultDecodeError`, whose cause is the error.
+   */
+  map<S extends SelectQueryState, Kind extends SelectQueryKind, R>(this: SelectQuery<S, Kind>, callback: (row: S["result"]) => R & SynchronousResult<R>): SelectQuery<ChangeState<S, {
+    result: R;
+    value: "mapped";
+    aggregate: true;
+  }>, Kind>;
+  /**
+   * Converts the whole result in code, after decoding, executed or nested, such as to group rows or to compute a value from them.
+   *
+   * `callback` receives what the query resolves to, once: the array of rows, one row, or `null` or `undefined` of a missing row of a nullable or optional query; it returns its result synchronously.
+   * The SQL stays as it is, so call it last: the returned query only executes, nests in a selection, and takes further `transform`.
+   * A failure of `callback` rejects with `ResultDecodeError`, whose cause is the error.
+   */
+  transform<S extends SelectQueryState, Kind extends SelectQueryKind, R>(this: SelectQuery<S, Kind>, callback: (result: QueryResult<S>) => R & SynchronousResult<R>): TransformedQuery<TransformedQueryState<S["table"], R, S["uses"]>, Kind>;
   /**
    * Returns the query that `callback` builds from this query, such as one with a conditional clause, or that a helper of `defineHelper` builds with `args`.
    *
@@ -1219,20 +1460,30 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * 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. */
+  /**
+   * 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.
+   *
+   * A query of `distinct` or `distinctOn` keeps the fields that `projection` replaces: `distinct` compares them, and the keys, the order, and the argument of an aggregate read a selected field through its projection.
+   */
   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`. */
+  /** 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;
+  /** Returns the rows mode of this query after a filter, as `FilteredStateRows` gives it in types. */
+  private getFilteredRows;
   /** 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 `method`, which reads or changes the fields of the query, on a query that `map` converts. */
+  private rejectMapped;
   /** 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;
+  /** Rejects `method`, an aggregate method or `exists`, on a query made by one of them or with a row lock. */
+  private rejectAggregation;
 }
 /** 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">;
@@ -1240,63 +1491,733 @@ type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
 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`. */
+/** 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>>;
-/** 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;
+/** 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]>; };
 /**
- * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+ * 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 type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
+ * 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.
  */
-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;
+type RelationRefs<C extends SchemaContext> = string extends C["key"] ? EmptyRecord : C["key"] extends keyof C["relations"] ? RelationQueries<C["relations"], C["key"]> : EmptyRecord;
+type RelationQueries<R extends SchemaContext["relations"], K extends keyof R & string> = { readonly [N in keyof R[K]]: RelatedQuery<R, K, N & string>; };
+/** Unbound query of the records of relation `N` of the table under key `K` of a schema of relations `R`, in the schema context of its target and the rows mode of the relation, whose row a required relation guarantees. */
+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 queries have as their own properties and which read the key columns from them. */
+  readonly relations: PropertyDescriptorMap;
 }
-/** 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<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.
+ * Direction of a sort key, optionally with the placement of `NULL`.
  *
- * 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.
+ * Without a placement, `NULL` comes last in ascending order and first in descending order.
  */
-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.
+type OrderDirection = "asc" | "desc" | "asc nulls first" | "asc nulls last" | "desc nulls first" | "desc nulls last";
+/** Columns of table `T` with the directions to sort by them, in the order of their keys. */
+type OrderColumns<T extends AnyTable> = { readonly [K in keyof T["columns"]]?: OrderDirection; };
+/** Argument of `orderBy` of a query over table `T`: a column key, sorted in ascending order, or columns with directions. */
+type OrderKey<T extends AnyTable> = (keyof T["columns"] & string) | OrderColumns<T>;
+declare const ordering: unique symbol;
+/** Expression or query of one value with the direction of its sort key, made by `asc`, `desc`, or `orderBy`. */
+interface Ordering {
+  readonly [ordering]: true;
+}
+/** Sort key returned by the callback of `orderBy`: an expression or a query of one value, such as of an aggregate of related records, sorted in ascending order, or one with a direction. */
+type OrderTerm = AnyExpression | ScalarQuery | Ordering;
+/**
+ * References of the callbacks of `orderBy`, `groupBy`, and `distinctOn` to the fields of records `R` selected by a query: their expressions by key.
+ *
+ * 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` gives 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. */
+type OrderTerms = OrderTerm | readonly OrderTerm[];
+/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
+declare function asc(value: AnyExpression | ScalarQuery): Ordering;
+/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
+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;
+/** Expression of a count: a number, with the operators of `orderingOperators`. */
+type CountExpression = Expression<number, CountValueType["operators"], CountValueType["input"]>;
+/** Expression of an aggregate of the values of `E`, an expression or a query of one value, `NULL` without values other than `NULL`, with the operators of its type. */
+type AggregateExpression<E extends TypedOperand> = Expression<OperandValue<E> | null, TypedOperandOperators<E>, TypedOperandInput<E>>;
+declare const groupValue: unique symbol;
+/** Value `T` of a directly selected expression in a nonempty group. */
+interface GroupValue<T> {
+  readonly [groupValue]: T;
+}
+/** Aggregate without a filter, whose value in a group keeps only the nullability of its argument. */
+type GroupAggregateExpression<E extends TypedOperand> = AggregateExpression<E> & GroupValue<OperandValue<E>>;
+/** Options of an aggregate function. */
+interface AggregateOptions {
+  /** Condition of the rows that the function aggregates, as `FILTER (WHERE ...)`: a Boolean expression or a query of one Boolean value. */
+  readonly filter?: AnyExpression<boolean | null> | ScalarQuery<boolean | null>;
+}
+/** Options of `stringAgg`. */
+interface StringAggOptions extends AggregateOptions {
+  /** Order in which the values are joined: a sort key or an array of them, as the callback of `orderBy` of a query returns; without it, PostgreSQL joins them in any order. */
+  readonly orderBy?: OrderTerms;
+}
+/** Options of an aggregate function without `filter`, which takes every row. */
+interface UnfilteredAggregateOptions {
+  /** No rows are removed from the aggregate input. */
+  readonly filter?: undefined;
+}
+/** Options of `stringAgg` without `filter`, which takes every row. */
+interface UnfilteredStringAggOptions extends UnfilteredAggregateOptions {
+  /** Order in which the values are joined: a sort key or an array of them, as the callback of `orderBy` of a query returns; without it, PostgreSQL joins them in any order. */
+  readonly orderBy?: OrderTerms;
+}
+/** Returns the number of the rows of the query that selects it, or of each of its groups, as `count(*)`. */
+declare function count(): CountExpression;
+/** Returns the number of the rows of the query that selects it, or of each of its groups, as `count(*)`; `options.filter` chooses the rows that it counts. */
+declare function count(options: AggregateOptions): CountExpression;
+/** Returns the number of the values of `value`, an expression with a type or a query of one value, other than `NULL`; `options.filter` chooses the rows that it takes. */
+declare function count(value: TypedOperand, options?: AggregateOptions): CountExpression;
+/** Returns the number of the distinct values of `value`, an expression with a type or a query of one value, other than `NULL`; `options.filter` chooses the rows that it takes. */
+declare function countDistinct(value: TypedOperand, options?: AggregateOptions): CountExpression;
+/** Returns the smallest of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`. */
+declare function min<E extends TypedOperand>(value: E, options?: UnfilteredAggregateOptions): GroupAggregateExpression<E>;
+/** Returns the smallest of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`; `options.filter` chooses the rows that it takes. */
+declare function min<E extends TypedOperand>(value: E, options?: AggregateOptions): AggregateExpression<E>;
+/** Returns the largest of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`. */
+declare function max<E extends TypedOperand>(value: E, options?: UnfilteredAggregateOptions): GroupAggregateExpression<E>;
+/** Returns the largest of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`; `options.filter` chooses the rows that it takes. */
+declare function max<E extends TypedOperand>(value: E, options?: AggregateOptions): AggregateExpression<E>;
+/** Returns the sum of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`. */
+declare function sum<E extends TypedOperand>(value: E, options?: UnfilteredAggregateOptions): GroupAggregateExpression<E>;
+/** Returns the sum of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`; `options.filter` chooses the rows that it takes. */
+declare function sum<E extends TypedOperand>(value: E, options?: AggregateOptions): AggregateExpression<E>;
+/**
+ * Returns the average of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`.
+ *
+ * For `bigint` values, average an expression of a type that can represent fractional values.
+ */
+declare function avg<E extends TypedOperand>(value: E, options?: UnfilteredAggregateOptions): GroupAggregateExpression<E>;
+/**
+ * Returns the average of the values of `value`, an expression with a type or a query of one value, or `null` without values other than `NULL`; `options.filter` chooses the rows that it takes.
+ *
+ * For `bigint` values, average an expression of a type that can represent fractional values.
+ */
+declare function avg<E extends TypedOperand>(value: E, options?: AggregateOptions): AggregateExpression<E>;
+/** Returns whether every value of `value`, a Boolean expression with a type or a query of one Boolean value, other than `NULL` is true, or `null` without such values. */
+declare function every<E extends TypedOperand>(value: E, options?: UnfilteredAggregateOptions): GroupAggregateExpression<E>;
+/** Returns whether every value of `value`, a Boolean expression with a type or a query of one Boolean value, other than `NULL` is true, or `null` without such values; `options.filter` chooses the rows that it takes. */
+declare function every<E extends TypedOperand>(value: E, options?: AggregateOptions): AggregateExpression<E>;
+/** Returns whether any value of `value`, a Boolean expression with a type or a query of one Boolean value, is true, or `null` without values other than `NULL`. */
+declare function some<E extends TypedOperand>(value: E, options?: UnfilteredAggregateOptions): GroupAggregateExpression<E>;
+/** Returns whether any value of `value`, a Boolean expression with a type or a query of one Boolean value, is true, or `null` without values other than `NULL`; `options.filter` chooses the rows that it takes. */
+declare function some<E extends TypedOperand>(value: E, options?: AggregateOptions): AggregateExpression<E>;
+/** Returns the values other than `NULL` of `value`, a text expression with a type or a query of one text value, joined with `delimiter` in the order of `options.orderBy`, or `null` without such values. */
+declare function stringAgg<E extends TypedOperand>(value: E, delimiter: string, options?: UnfilteredStringAggOptions): GroupAggregateExpression<E>;
+/** Returns the values other than `NULL` of `value`, a text expression with a type or a query of one text value, joined with `delimiter` in the order of `options.orderBy`, or `null` without such values; `options.filter` chooses the rows that it takes. */
+declare function stringAgg<E extends TypedOperand>(value: E, delimiter: string, options?: StringAggOptions): AggregateExpression<E>;
+/**
+ * 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>;
+/** 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, also converted by `map` or `transform`. */
+type NestedQuery = QueryOf<SelectQueryState> | TransformedQuery<TransformedQueryState, SelectQueryKind>;
+/** 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]>; };
+/** Record of a selection in a query of groups. */
+type GroupSelectionResult<S extends Selection> = { [K in keyof S]: GroupFieldValue<S[K]>; };
+/** Value of a field selected in a group, leaving nested queries and literals unchanged. */
+type GroupFieldValue<V> = V extends GroupValue<infer T> ? T : FieldValue<V>;
+/** Value of an operand in a query of groups. */
+type GroupOperandValue<E> = E extends GroupValue<infer T> ? T : OperandValue<E>;
+/** 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;
+}
+/** Result `R` of a callback of a helper without the marker, which a record of the callback keeps, also through a spread, so that the declarations of a module exporting a helper never name it; `any` stays `any`. */
+type WithoutHelperFields<R> = IsAny<R> extends true ? R : R extends HelperFields ? { [K in keyof R as K extends keyof HelperFields ? never : K]: R[K]; } : R;
+/** 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]; }>;
+/** Types of the values of columns `K` of table `T` as selected fields: the values that each encodes and its operators. */
+type ColumnFieldTypes<T extends AnyTable, K extends keyof T["columns"]> = { [P in K]: ColumnValueType<T, P>; };
+/** Types of the values of the expressions and the queries of one value of selection `Sel`, under the keys of the result records, as `MergeSelection` normalizes them. */
+type SelectionFieldTypes<Sel> = { [K in keyof Sel as K extends number ? `${K}` : K]: FieldType<Exclude<Sel[K], undefined>>; };
+/** Type of the value of a selected field `F`, for each member of a union of them, so that each keeps its own operators and values. */
+type FieldType<F> = F extends TypedOperand ? F extends GroupValue<infer T> ? OperandValueType<F> & {
+  readonly group: T;
+} : OperandValueType<F> : unknown;
+/** Record `R` of a query whose rows become groups, with field types `F`. */
+type GroupedRecord<R, F> = IsAny<R> extends true ? R : R extends unknown ? { [K in keyof R]: K extends keyof F ? GroupedField<R[K], Exclude<F[K], undefined>> : R[K]; } : never;
+/** Value of a selected field after grouping; a union of field types must all guarantee a non-null value to remove `null`. */
+type GroupedField<V, D> = [D] extends [{
+  readonly group: infer G;
+}] ? null extends G ? V : Exclude<V, null> : V;
+/** Types of the values of fields `P` with those of fields `N` added or replaced, by the rules of `MergeSelection`, for each branch of either. */
+type MergeFieldTypes<P, N> = P extends unknown ? N extends unknown ? [keyof N] extends [never] ? P : [keyof P] extends [never] ? N : { [K in keyof P | keyof N]: K extends keyof N ? {} extends Pick<N, K> ? K extends keyof P ? P[K] | Exclude<N[K], undefined> : Exclude<N[K], undefined> : N[K] : K extends keyof P ? P[K] : never; } : never : never;
+/** Types of the values of the selected fields of a query: those of `P`, the `fieldTypes` part of the state before a selection, with `N` added or replaced. */
+interface SelectedFieldTypes<out P, N> {
+  readonly types: MergeFieldTypes<SelectedFieldTypesOf<P>, N>;
+}
+/** Types of the values of the selected fields of the `fieldTypes` part `F` of a state, by key; none for `EmptyRecord` of a query without selected fields. */
+type SelectedFieldTypesOf<F> = F extends SelectedFieldTypes<unknown, unknown> ? F["types"] : EmptyRecord;
+/** 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>>;
+/**
+ * Returns the first of its operands other than `NULL`, such as `coalesce(field.hint, "")`, as an expression usable wherever a column is.
+ *
+ * `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.
+ */
+declare function coalesce<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
+/**
+ * Returns the largest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
+ *
+ * `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`.
+ */
+declare function greatest<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
+/**
+ * Returns the smallest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
+ *
+ * `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`.
+ */
+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>;
+/**
+ * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `NULL` when none holds.
+ *
+ * `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 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>;
+/**
+ * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `otherwise` when none holds.
+ *
+ * `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 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 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.
+ *
+ * It is guaranteed, so that the state that the callback returns tells whether the callback ends the guarantee of the query the helper is applied to.
+ */
+interface HelperState<T extends AnyTable, C extends SchemaContext> extends QueryStateOf<T, C> {
+  readonly result: HelperFields<never>;
+  readonly valueType: never;
+  readonly fieldTypes: EmptyRecord;
+  readonly rows: "many";
+  readonly value: false;
+  readonly uses: never;
+  readonly guaranteed: true;
+  readonly aggregate: false;
+}
+/**
+ * Effect of a helper: the fields it selects and the types of their values, or whether `map` converts its rows and what it gives, its rows mode on a query of many rows, `one` after `take` or `required` and `nullable` or `optional` after the method of the same name, the relations it selects records of, and whether it keeps the guarantee of the row of a query of a required relation.
+ *
+ * `reads` are the relations of the schema of the helper among them, which its callback may read from the references of the query it is applied to, and `key` is the key of its table there.
+ */
+interface HelperEffect {
+  /** Whether the helper guarantees that the query is grouped. */
+  readonly grouped: boolean;
+  readonly fields: object;
+  /** Types of the values of the fields it selects, the `fieldTypes` part of the state that its callback returns, which `having` and the narrowing of grouped selections read. */
+  readonly fieldTypes: unknown;
+  /** Whether `map` converts the rows, whose fields the result no longer tells, so that `fields` are empty. */
+  readonly mapped: boolean;
+  /** What `map` gives for each row of a query the helper is applied to; `never` when `mapped` is `false`. */
+  readonly output: unknown;
+  readonly rows: ResultRows;
+  readonly uses: UsedRelation;
+  readonly reads: UsedRelation;
+  readonly key: string;
+  readonly guaranteed: boolean;
+}
+/** Effect of a helper whose callback returns a query of state `S`, for each state of a union. */
+type ReadEffect<S extends SelectQueryState> = S extends SelectQueryState ? {
+  readonly grouped: S["aggregate"] extends Grouped ? true : false;
+  readonly fields: S["value"] extends "mapped" ? EmptyRecord : { [K in keyof S["result"] as K extends keyof HelperFields ? never : K]: S["result"][K]; };
+  readonly fieldTypes: S["value"] extends "mapped" ? EmptyRecord : S["fieldTypes"];
+  readonly mapped: S["value"] extends "mapped" ? true : false;
+  readonly output: S["value"] extends "mapped" ? WithoutHelperFields<S["result"]> : never;
+  readonly rows: S["rows"];
+  readonly uses: S["uses"];
+  readonly reads: Extract<UsableRelation<S["schema"]["relations"]>, S["uses"]>;
+  readonly key: S["schema"]["key"];
+  readonly guaranteed: S["guaranteed"];
+} : never;
+/** Error of a helper that a query does not accept, or whose callback returns a query it does not accept. */
+interface HelperError<Message extends string> {
+  readonly error: Message;
+}
+/** `unknown` when every result state retains the input marker and returns records, or converts such records with `map`, or the error. */
+type CheckResult<S extends SelectQueryState> = [S] extends [{
+  readonly result: HelperFields;
+  readonly value: false;
+} | {
+  readonly value: "mapped";
+  readonly valueType: never;
+}] ? unknown : HelperError<"A helper can filter, select fields, map them, and take one row, but cannot clear the selection or use get, pluck, or aggregates">;
+/** State of a query over table `T` that accepts a helper of effect `E`. */
+type HelperInput<T extends AnyTable, E extends HelperEffect> = QueryStateOf<T, ReadsContext<E>> & ValueCheck<E> & (true extends E["grouped"] ? {
+  readonly aggregate: false;
+} : unknown);
+/** Constraint of `value` of a query that accepts a helper of effect `E`. */
+type ValueCheck<E extends HelperEffect> = [E extends HelperEffect ? keyof E["fields"] : never] extends [never] ? [Extract<E["rows"], "nullable">] extends [never] ? [E["mapped"]] extends [false] ? unknown : RecordRows<"A helper cannot apply map to a query made by get, pluck, an aggregate, or map"> : RecordRows<"A helper cannot apply nullable to a query made by get, pluck, an aggregate, or map"> : RecordRows<"A helper cannot select fields on a query made by get, pluck, an aggregate, or map">;
+/** Constraint of a query whose rows are records, which a query of values fails with error `Message`. */
+interface RecordRows<Message extends string> {
+  readonly value: false | HelperError<Message>;
+}
+/** Schema context of a query that has the relations of its schema that a helper of effect `E` may read. */
+type ReadsContext<E extends HelperEffect> = [E["reads"]] extends [never] ? SchemaContext : SchemaContext<{ readonly [K in E["reads"]["key"]]: { readonly [N in Extract<E["reads"], {
+  readonly key: K;
+}>["name"]]: Extract<E["reads"], {
+  readonly key: K;
+  readonly name: N;
+}>["relation"]; }; }, E["key"]>;
+/** State of a query of state `S` after a helper of effect `E`. */
+type ApplyEffect<S extends SelectQueryState, E extends HelperEffect> = ApplySelectionEffect<E["grouped"] extends true ? GroupedState<S> : S, E>;
+/** Applies the selected fields and row effects after the grouping guaranteed by the helper. */
+type ApplySelectionEffect<S extends SelectQueryState, E extends HelperEffect> = ChangeState<S, {
+  result: E["mapped"] extends true ? E["output"] : [keyof E["fields"]] extends [never] ? S["result"] : MergeSelection<S["result"], S["aggregate"] extends Grouped ? GroupedRecord<E["fields"], SelectedFieldTypesOf<E["fieldTypes"]>> : E["fields"]>;
+  fieldTypes: SelectedFieldTypes<S["fieldTypes"], SelectedFieldTypesOf<E["fieldTypes"]>>;
+  value: E["mapped"] extends true ? "mapped" : S["value"];
+  aggregate: E["mapped"] extends true ? true : S["aggregate"];
+  rows: E["rows"] extends "many" ? EffectRows<S, E> : E["rows"] extends "one" ? OneRow<EffectRows<S, E>> : E["rows"];
+  uses: S["uses"] | E["uses"];
+  guaranteed: E["guaranteed"] extends true ? S["guaranteed"] : false;
+}>;
+/** Rows mode of a query of state `S` after a helper of effect `E` that keeps the rows, before `take`: relaxed as after a filter when the helper ends the guarantee. */
+type EffectRows<S extends SelectQueryState, E extends HelperEffect> = E["guaranteed"] extends true ? S["rows"] : FilteredStateRows<S>;
+/**
+ * Helper of `defineHelper` for queries over table `T`: it applies effect `E` to the query it receives with arguments `A` and returns a query of the same kind.
+ *
+ * Selected fields replace earlier fields under the same keys; a query made by `get`, `pluck`, an aggregate method, or `map` does not accept a helper that selects fields or maps them.
+ * `use` of a mutation also applies a helper that only selects fields and maps them.
+ */
+type Helper<T extends AnyTable, E extends HelperEffect, A extends unknown[]> = <S extends HelperInput<T, E>, Kind extends SelectQueryKind>(query: SelectQuery<S, Kind>, ...args: A) => E extends HelperEffect ? SelectQuery<ApplyEffect<S, E>, Kind> : never;
+/**
+ * Defines a reusable helper of a table that filters, selects fields, converts them with `map`, and applies `take`, `optional`, `nullable`, and `required`, used with `use` or called with a query.
+ *
+ * `helper` receives the query it is applied to and any further arguments, and returns the query with its clauses.
+ * Defined with a query of a schema, such as `schema.form`, it can select the relations of the table in that schema, and applies to queries whose schema has them.
+ * The helper returns a query of the same kind as the one it is applied to, bound to the same `Db` if any.
+ * A helper that only selects fields and maps them also applies to an insert, an update, and a delete with their `use`, where it selects what they return; other methods fail there.
+ */
+declare function defineHelper<T extends AnyTable, R extends SelectQuery<any, SelectQueryKind>, A extends unknown[], C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, helper: (query: SelectQuery<HelperState<T, C>, SelectQueryKind>, ...args: A) => R & CheckResult<R["types"]>): Helper<T, ReadEffect<R["types"]>, A>;
+/**
+ * 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 or `transform` converts it.
+ *
+ * Methods change only their own parts of the state.
+ */
+interface MutationQueryState extends QueryState {
+  readonly table: AnyTable;
+  readonly schema: SchemaContext;
+  /** Rows mode of the rows that the query changes, which `select`, `get`, and `pluck` return. */
+  readonly changed: ResultRows;
+  /** Whether the query resolves to something other than the number of the rows it changes: their fields or what `transform` makes of that 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, 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;
+  readonly returning: false;
+  readonly result: number;
+  readonly rows: "one";
+  readonly value: true;
+  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]; } & {};
+/** State of a mutation that returns the number of the rows it changes or their records, which `select` applies to. */
+type RecordMutationState = MutationQueryState & ({
+  readonly returning: false;
+} | {
+  readonly value: false;
+});
+/** State of a mutation that `map` and `transform` do not convert, which `pluck` applies to. */
+type UnconvertedMutationState = MutationQueryState & {
+  readonly value: boolean;
+};
+/** State of a mutation of one row that `map` and `transform` do not convert, which `get` applies to. */
+type OneRowMutationState = UnconvertedMutationState & {
+  readonly changed: "one" | "nullable" | "optional";
+};
+/** State of a mutation that returns the fields of the rows it changes, which `map` applies to unless `transform` converts it; the number of the rows has no rows to convert. */
+type ReturningMutationState = MutationQueryState & {
+  readonly returning: true;
+  readonly value: boolean | "mapped";
+};
+/** Constraint of a mutation that does not accept a helper that filters or takes one row, whose methods it lacks. */
+interface NotMutationEffect {
+  readonly returning: HelperError<"A helper of a mutation can only select fields and map them">;
+}
+/** Constraint of a mutation that accepts a helper of table `T` of effect `E`, whose callback reads the relations of its schema context from the mutation. */
+type HelperMutationInput<T extends AnyTable, E extends HelperEffect> = MutationQueryState & {
+  readonly table: T;
+  readonly schema: ReadsContext<E>;
+} & ([E["guaranteed"]] extends [true] ? [E["rows"]] extends ["many"] ? [E extends HelperEffect ? keyof E["fields"] : never, E["mapped"]] extends [never, false] ? unknown : RecordMutationState : NotMutationEffect : NotMutationEffect);
+/** State of a mutation of state `S` after a helper of effect `E`: the rows that `map` gives, or the records with the fields that it selects. */
+type HelperMutationState<S extends MutationQueryState, E extends HelperEffect> = E["mapped"] extends true ? ChangeMutationState<S, {
+  result: E["output"];
+  rows: S["changed"];
+  value: "mapped";
+  returning: true;
+  uses: S["uses"] | E["uses"];
+}> : [keyof E["fields"]] extends [never] ? ChangeMutationState<S, {
+  uses: S["uses"] | E["uses"];
+}> : RecordsState<S, E["fields"], E["uses"]>;
+/** Record that the returned fields of a mutation of state `S` add to: the fields selected earlier, or none. */
+type ReturnedRecord$1<S extends MutationQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
+/** State of a mutation of state `S` that returns records with `Fields`, which its nested queries select records of relations `U` for. */
+type RecordsState<S extends MutationQueryState, Fields, U extends UsedRelation = never> = ChangeMutationState<S, {
+  result: MergeSelection<ReturnedRecord$1<S>, Fields>;
+  rows: S["changed"];
+  value: false;
+  returning: true;
+  uses: S["uses"] | U;
+}>;
+/** State of a mutation of state `S` that returns value `V` of each row it changes in rows mode `Rows`. */
+type ValueState$1<S extends MutationQueryState, V, Rows extends ResultRows> = ChangeMutationState<S, {
+  result: V;
+  rows: Rows;
+  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`.
+ *
+ * Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead, and `map` and `transform` convert them in code.
+ * 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 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 its callbacks receive. */
+  readonly context: QueryContext;
+  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(table: S["table"], node: MutationNode,
+  /** 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>;
+  /** Returns the listed columns of each changed row, replacing fields under their keys, instead of the number of the rows. */
+  select<S extends RecordMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, ...keys: K[]): MutationQuery<RecordsState<S, Pick<Selectable<S["table"]>, K>>, Kind>;
+  /**
+   * Returns the expressions and nested queries that `callback` returns for each changed row, replacing fields under their keys, instead of the number of the rows.
+   *
+   * `callback` receives the columns of the changed row, with their values after an insert or an update and those of the deleted row, and the queries of the relations of the table, as the callback of `select` of a select query does.
+   * A nested query reads the database as it was before the change, apart from the changed row.
+   */
+  select<S extends RecordMutationState, Kind extends SelectQueryKind, Sel extends Selection>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => Sel): MutationQuery<RecordsState<S, SelectionResult<Sel>, SelectionUses<Sel>>, Kind>;
+  /**
+   * Returns the value of a column of the changed row instead of the number of the rows, in a query that changes one row, such as of `insert` or `find`.
+   *
+   * A query of a nullable row resolves to `undefined` without the row.
+   */
+  get<S extends OneRowMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], OneValueRows<S["changed"]>>, Kind>;
+  /**
+   * 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 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 UnconvertedMutationState, 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.
+   *
+   * `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 UnconvertedMutationState, 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>;
+  /**
+   * Converts each record or value that the mutation returns in code, after decoding, such as to add a field that SQL cannot compute; select the fields before it, since the number of the rows has no rows to convert, which `transform` converts instead.
+   *
+   * `callback` receives one record or value, also `null` of a `NULL` value, and is not called for a missing row; it returns its result synchronously.
+   * A failure of `callback` rejects with `ResultDecodeError`, after the mutation has changed its rows.
+   */
+  map<S extends ReturningMutationState, Kind extends SelectQueryKind, R>(this: MutationQuery<S, Kind>, callback: (row: S["result"]) => R & SynchronousResult<R>): MutationQuery<ChangeMutationState<S, {
+    result: R;
+    value: "mapped";
+  }>, Kind>;
+  /**
+   * Converts the whole result of the mutation in code, after decoding, such as the number of the rows it changes into whether it changed any.
+   *
+   * `callback` receives what the mutation resolves to, once, and returns its result synchronously; call `select`, `get`, `pluck`, and `map` before it.
+   * A failure of `callback` rejects with `ResultDecodeError`, after the mutation has changed its rows.
+   */
+  transform<S extends MutationQueryState, Kind extends SelectQueryKind, R>(this: MutationQuery<S, Kind>, callback: (result: QueryResult<S>) => R & SynchronousResult<R>): MutationQuery<ChangeMutationState<S, {
+    result: R;
+    rows: "one";
+    value: "transformed";
+    returning: true;
+  }>, Kind>;
+  /**
+   * Returns the mutation that `callback` builds from this mutation, such as one that selects the fields it returns.
+   *
+   * `callback` receives this mutation and `args` and returns this mutation or a mutation derived from it, which keeps the binding of this mutation.
+   */
+  use<Q, Kind extends SelectQueryKind, R extends MutationQuery<any, Kind>, A extends unknown[] = []>(this: Q & MutationQuery<any, Kind>, callback: (query: Q, ...args: A) => R, ...args: A): R;
+  /**
+   * Applies a helper of `defineHelper` that only selects fields and maps them to what the mutation returns, as `use` of a select query does.
+   *
+   * Another method of a query in the helper fails: types reject those that filter or take one row, but not `groupBy`, `orderBy`, `limit`, `offset`, `distinct`, `distinctOn`, and the row locks, which they do not tell from a selection.
+   * A selection of no fields fails as well on a mutation that returns the number of its rows.
+   */
+  use<S extends HelperMutationInput<T, E>, Kind extends SelectQueryKind, T extends AnyTable, E extends HelperEffect, A extends unknown[]>(this: MutationQuery<S, Kind>, helper: Helper<T, E, A>, ...args: A): E extends HelperEffect ? MutationQuery<HelperMutationState<S, E>, Kind> : never;
+  /**
+   * 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;
+  /** 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 the relations and returns an expression or a query of one value, of each changed row. */
+  private deriveValue;
+  /** Rejects `method`, which changes the fields that the mutation returns, on a mutation that `map` or `transform` converts. */
+  private rejectConverted;
+}
+/** Query of any state and kind that inserts, updates, or deletes rows. */
+type AnyMutationQuery = MutationQuery<any, SelectQueryKind>;
+/** Types of the fields of the rows of a query of SQL text by the names of the result columns they decode. */
+interface FieldTypes {
+  readonly [key: string]: AnyType;
+  readonly [key: symbol]: never;
+}
+/** Record of the values that the types of fields `F` decode. */
+type DecodedFields<F extends FieldTypes> = { -readonly [K in keyof F]: TypeOutput<F[K]>; };
+/**
+ * State in types of a query of SQL text: the rows mode of the rows that its statement returns, and its result, which is the number of the rows of its command tag until a selection returns their fields.
+ *
+ * Methods change only their own parts of the state.
+ */
+interface SqlQueryState extends QueryState {
+  /** Rows mode of the rows of the statement, which `select`, `get`, and `pluck` return. */
+  readonly returned: ResultRows;
+  /** Whether the query returns the fields of the rows of the statement rather than their number. */
+  readonly returning: boolean;
+}
+/** State of a query of SQL text that returns the number of the rows of its command tag. */
+interface InitialSqlQueryState extends SqlQueryState {
+  readonly result: number;
+  readonly rows: "one";
+  readonly value: true;
+  readonly uses: never;
+  readonly returned: "many";
+  readonly returning: false;
+}
+/** State `S` of a query of SQL text with the parts of `Changes` replaced. */
+type ChangeSqlQueryState<S extends SqlQueryState, Changes extends Partial<SqlQueryState>> = { readonly [K in keyof SqlQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
+/** State of a query of SQL text that returns the number of the rows or their records, which `select` applies to. */
+type RecordSqlQueryState = SqlQueryState & ({
+  readonly returning: false;
+} | {
+  readonly value: false;
+});
+/** State of a query of SQL text of one row, which `optional` applies to. */
+type OneRowSqlQueryState = SqlQueryState & {
+  readonly returned: "one" | "nullable" | "optional";
+};
+/** State of a query of SQL text of one row that returns its number or its record, which `nullable` applies to. */
+type OneRecordSqlQueryState = OneRowSqlQueryState & RecordSqlQueryState;
+/** Record that the fields of a query of SQL text of state `S` add to: the fields selected earlier, or none. */
+type ReturnedRecord<S extends SqlQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
+/** State of a query of SQL text of state `S` whose rows are in rows mode `Rows`. */
+type RowsState<S extends SqlQueryState, Rows extends ResultRows> = ChangeSqlQueryState<S, {
+  returned: Rows;
+  rows: S["returning"] extends true ? Rows : "one";
+}>;
+/** State of a query of SQL text of state `S` that returns value `V` of each row in rows mode `Rows`. */
+type ValueState<S extends SqlQueryState, V, Rows extends ResultRows> = ChangeSqlQueryState<S, {
+  result: V;
+  rows: Rows;
+  returned: Rows;
+  value: true;
+  returning: true;
+}>;
+/**
+ * Immutable query of a statement of SQL text, bound to the `Db` that executes it when awaited.
+ *
+ * Without a selection, it resolves to the number of the rows of the command tag of its statement, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of the rows of the statement instead, decoded by types.
+ */
+declare class SqlQuery<out S extends SqlQueryState> {
+  readonly node: TextStatementNode;
+  /** `Db` that executes the query when it is awaited. */
+  readonly db: AnyDb;
+  readonly types: S;
+  /** Executes the query on its `Db`. */
+  readonly then: QueryThen<S, "bound">;
+  constructor(node: TextStatementNode,
+  /** `Db` that executes the query when it is awaited. */
+  db: AnyDb);
+  /**
+   * Returns the records of the rows of the statement instead of their number, with the values of the result columns named by the keys of `fields`, decoded by their types; it adds the fields to those selected earlier, replacing fields under their keys.
+   *
+   * A type of a column that can be `NULL` must be nullable.
+   * The statement rejects without a column of a field, or with the column twice; other columns are ignored.
+   */
+  select<S extends RecordSqlQueryState, F extends FieldTypes>(this: SqlQuery<S>, fields: F): SqlQuery<ChangeSqlQueryState<S, {
+    result: MergeSelection<ReturnedRecord<S>, DecodedFields<F>>;
+    rows: S["returned"];
+    value: false;
+    returning: true;
+  }>>;
+  /**
+   * Returns the value of the only column of the row of the statement instead of the number of the rows, decoded by `type`.
+   *
+   * Without a row, it rejects with `NotFoundError` unless `optional` makes the query resolve to `undefined`; it rejects several rows.
+   * A `NULL` value is `null`, so a type of a column that can be `NULL` must be nullable.
+   */
+  get<S extends SqlQueryState, T extends AnyType>(this: SqlQuery<S>, type: T): SqlQuery<ValueState<S, TypeOutput<T>, OneValueRows<S["returned"]>>>;
+  /**
+   * Returns the values of the only column of the rows of the statement instead of their number, decoded by `type`, keeping whether the query returns an array or one value.
+   *
+   * A `NULL` value is `null`, so a type of a column that can be `NULL` must be nullable.
+   */
+  pluck<S extends SqlQueryState, T extends AnyType>(this: SqlQuery<S>, type: T): SqlQuery<ValueState<S, TypeOutput<T>, ValueRows<S["returned"]>>>;
+  /**
+   * Returns the row of the statement instead of an array, and rejects with `NotFoundError` without it and with several rows; it adds no limit to the statement.
+   *
+   * Before a selection, the query resolves to the number of the rows, `1`, and rejects as well.
+   */
+  take<S extends SqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, OneRow<S["returned"]>>>;
+  /**
+   * Makes a query of one row, such as one of `take` or `get`, resolve to `undefined` without the row.
+   *
+   * Before a selection, the query resolves to `0` without the row.
+   */
+  optional<S extends OneRowSqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, "optional">>;
+  /**
+   * Makes a query of one record, such as one of `take`, resolve to `null` without the row.
+   *
+   * A value of `get` or `pluck` is never `null` for a missing row, which would read as a `NULL` value, so a query of values does not accept it.
+   * Before a selection, the query resolves to `0` without the row.
+   */
+  nullable<S extends OneRecordSqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, "nullable">>;
+  /** Compiles the query into SQL text and parameters, as its `Db` executes it. */
+  toSQL(): SqlStatement;
+  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+  [operandNode](): never;
+  /** Creates a query of the same `Db` with the node changes applied. */
+  private derive;
+  /** Creates the query that returns the value of the only column of each row in rows mode `rows`, decoded by `type` of `method`. */
+  private deriveValue;
+  /** Creates the query of one row in rows mode `rows`, rejecting a query of many rows. */
+  private changeOneRow;
+}
+/** Query of SQL text of any state. */
+type AnySqlQuery = SqlQuery<any>;
+/** Kind of a select query: `unbound`, or `bound` to a `Db`. */
+type SelectQueryKind = "unbound" | "bound";
+/**
+ * `then` of a query of kind `Kind`: a bound query executes when awaited, and an unbound query is not thenable.
+ *
+ * Awaiting a query of either kind or returning it from an async function is a type error, since it may execute.
+ */
+type QueryThen<S extends QueryState, Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? <R1 = QueryResult<S>, R2 = never>(onFulfilled?: ((result: QueryResult<S>) => R1 | PromiseLike<R1>) | null, onRejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null) => Promise<R1 | R2> : [Kind] extends ["unbound"] ? undefined : ((onFulfilled: never) => unknown) | undefined;
+/** `Db` of a query of kind `Kind`, which only a bound query has. */
+type QueryDb<Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? AnyDb : [Kind] extends ["unbound"] ? undefined : AnyDb | undefined;
+/** Arguments of `toSQL` of a query of kind `Kind`: a bound query compiles with the options of its `Db`. */
+type ToSQLArgs<Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? [] : [options?: CompileOptions];
+/** Query of any class, state, and kind: a select query of a table, one converted by `transform`, a query of `$select`, one that inserts, updates, or deletes rows, or a query of SQL text. */
+type AnyQuery = AnySelectQuery | AnyTransformedQuery | AnyRecordQuery | AnyMutationQuery | AnySqlQuery;
+/** 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 of its literals 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 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, 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.
    */
@@ -1507,272 +2428,59 @@ type TableContext<R extends SchemaRelations, K> = K extends keyof R ? [keyof R[K
  * A composite key lists its columns in arrays of the same length.
  */
 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>;
-/**
- * Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
- *
- * 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.
- */
-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>>>;
-/**
- * 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.
- *
- * Methods change only their own parts of the state.
- */
-interface MutationQueryState extends QueryState {
-  readonly table: AnyTable;
-  readonly schema: SchemaContext;
-  /** Rows mode of the rows that the query changes, which `select`, `get`, and `pluck` return. */
-  readonly changed: ResultRows;
-  /** 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 {
-  readonly table: T;
-  readonly schema: C;
-  readonly changed: Rows;
-  readonly returning: false;
-  readonly result: number;
-  readonly rows: "one";
-  readonly value: true;
-  readonly uses: never;
-}
-/** 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]; } & {};
-/** State of a mutation that returns the number of the rows it changes or their records, which `select` applies to. */
-type RecordMutationState = MutationQueryState & ({
-  readonly returning: false;
-} | {
-  readonly value: false;
-});
-/** State of a mutation of one row, which `get` applies to. */
-type OneRowMutationState = MutationQueryState & {
-  readonly changed: "one" | "nullable" | "optional";
-};
-/** Record that the returned fields of a mutation of state `S` add to: the fields selected earlier, or none. */
-type ReturnedRecord$1<S extends MutationQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
-/** State of a mutation of state `S` that returns records with `Fields`, which its nested queries select records of relations `U` for. */
-type RecordsState<S extends MutationQueryState, Fields, U extends UsedRelation = never> = ChangeMutationState<S, {
-  result: MergeSelection<ReturnedRecord$1<S>, Fields>;
-  rows: S["changed"];
-  value: false;
-  returning: true;
-  uses: S["uses"] | U;
-}>;
-/** State of a mutation of state `S` that returns value `V` of each row it changes in rows mode `Rows`. */
-type ValueState$1<S extends MutationQueryState, V, Rows extends ResultRows> = ChangeMutationState<S, {
-  result: V;
-  rows: Rows;
-  value: true;
-  returning: true;
-}>;
-/**
- * Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
- *
- * Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead.
- * 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 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. */
-  readonly context: QueryContext;
-  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(table: S["table"], node: MutationNode,
-  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
-  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>;
-  /** Returns the listed columns of each changed row, replacing fields under their keys, instead of the number of the rows. */
-  select<S extends RecordMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, ...keys: K[]): MutationQuery<RecordsState<S, Pick<Selectable<S["table"]>, K>>, Kind>;
-  /**
-   * Returns the expressions and nested queries that `callback` returns for each changed row, replacing fields under their keys, instead of the number of the rows.
-   *
-   * `callback` receives the columns of the changed row, with their values after an insert or an update and those of the deleted row, and the queries of the relations of the table, as the callback of `select` of a select query does.
-   * A nested query reads the database as it was before the change, apart from the changed row.
-   */
-  select<S extends RecordMutationState, Kind extends SelectQueryKind, Sel extends Selection>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => Sel): MutationQuery<RecordsState<S, SelectionResult<Sel>, SelectionUses<Sel>>, Kind>;
-  /**
-   * Returns the value of a column of the changed row instead of the number of the rows, in a query that changes one row, such as of `insert` or `find`.
-   *
-   * A query of a nullable row resolves to `undefined` without the row.
-   */
-  get<S extends OneRowMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], OneValueRows<S["changed"]>>, Kind>;
-  /**
-   * 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`.
-   *
-   * 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>;
-  /** 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>;
-  /**
-   * 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;
-  /** 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. */
-  private deriveValue;
-}
-/** Query of any state and kind that inserts, updates, or deletes rows. */
-type AnyMutationQuery = MutationQuery<any, SelectQueryKind>;
-/** Types of the fields of the rows of a query of SQL text by the names of the result columns they decode. */
-interface FieldTypes {
-  readonly [key: string]: AnyType;
-  readonly [key: symbol]: never;
-}
-/** Record of the values that the types of fields `F` decode. */
-type DecodedFields<F extends FieldTypes> = { -readonly [K in keyof F]: TypeOutput<F[K]>; };
-/**
- * State in types of a query of SQL text: the rows mode of the rows that its statement returns, and its result, which is the number of the rows of its command tag until a selection returns their fields.
- *
- * Methods change only their own parts of the state.
- */
-interface SqlQueryState extends QueryState {
-  /** Rows mode of the rows of the statement, which `select`, `get`, and `pluck` return. */
-  readonly returned: ResultRows;
-  /** Whether the query returns the fields of the rows of the statement rather than their number. */
-  readonly returning: boolean;
-}
-/** State of a query of SQL text that returns the number of the rows of its command tag. */
-interface InitialSqlQueryState extends SqlQueryState {
-  readonly result: number;
+/**
+ * Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+ *
+ * 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.
+ */
+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 that the result of a callback of `transform` and `map` is checked against when it may be a Promise. */
+interface NotSynchronous {
+  readonly "the callback must return its result synchronously": never;
+}
+/** Check of `R`, the result of a callback of `transform` and `map`: it fails against `NotSynchronous` when `R` may be a Promise, such as a union with one, but not for `any` and `unknown`. */
+type SynchronousResult<R> = [Extract<R, PromiseLike<unknown>>] extends [never] ? unknown : IsAny<R> extends true ? unknown : NotSynchronous;
+/** State of a query of `transform` of a table in types: over table `T`, whose whole result is `R`, selecting records of relations `U`. */
+interface TransformedQueryState<T extends AnyTable = AnyTable, R = unknown, U extends UsedRelation = UsedRelation> extends QueryState {
+  readonly table: T;
+  readonly result: R;
   readonly rows: "one";
-  readonly value: true;
-  readonly uses: never;
-  readonly returned: "many";
-  readonly returning: false;
+  readonly value: "transformed";
+  readonly uses: U;
 }
-/** State `S` of a query of SQL text with the parts of `Changes` replaced. */
-type ChangeSqlQueryState<S extends SqlQueryState, Changes extends Partial<SqlQueryState>> = { readonly [K in keyof SqlQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
-/** State of a query of SQL text that returns the number of the rows or their records, which `select` applies to. */
-type RecordSqlQueryState = SqlQueryState & ({
-  readonly returning: false;
-} | {
-  readonly value: false;
-});
-/** State of a query of SQL text of one row, which `optional` applies to. */
-type OneRowSqlQueryState = SqlQueryState & {
-  readonly returned: "one" | "nullable" | "optional";
-};
-/** State of a query of SQL text of one row that returns its number or its record, which `nullable` applies to. */
-type OneRecordSqlQueryState = OneRowSqlQueryState & RecordSqlQueryState;
-/** Record that the fields of a query of SQL text of state `S` add to: the fields selected earlier, or none. */
-type ReturnedRecord<S extends SqlQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
-/** State of a query of SQL text of state `S` whose rows are in rows mode `Rows`. */
-type RowsState<S extends SqlQueryState, Rows extends ResultRows> = ChangeSqlQueryState<S, {
-  returned: Rows;
-  rows: S["returning"] extends true ? Rows : "one";
-}>;
-/** State of a query of SQL text of state `S` that returns value `V` of each row in rows mode `Rows`. */
-type ValueState<S extends SqlQueryState, V, Rows extends ResultRows> = ChangeSqlQueryState<S, {
-  result: V;
-  rows: Rows;
-  returned: Rows;
-  value: true;
-  returning: true;
-}>;
 /**
- * Immutable query of a statement of SQL text, bound to the `Db` that executes it when awaited.
+ * Immutable query of a table of state `S` whose whole result `transform` converts after decoding, unbound or bound to a `Db`.
  *
- * Without a selection, it resolves to the number of the rows of the command tag of its statement, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of the rows of the statement instead, decoded by types.
+ * It executes and nests in a selection as the query it comes from, with the same SQL, so it has only `transform`, which converts the result further: another method would change what the callback receives, and an expression does not take it, since SQL does not see the conversion.
+ * 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 SqlQuery<out S extends SqlQueryState> {
-  readonly node: TextStatementNode;
-  /** `Db` that executes the query when it is awaited. */
-  readonly db: AnyDb;
+declare class TransformedQuery<out S extends TransformedQueryState, out Kind extends SelectQueryKind = "unbound"> {
+  readonly node: QueryNode;
   readonly types: S;
-  /** Executes the query on its `Db`. */
-  readonly then: QueryThen<S, "bound">;
-  constructor(node: TextStatementNode,
-  /** `Db` that executes the query when it is awaited. */
-  db: AnyDb);
-  /**
-   * Returns the records of the rows of the statement instead of their number, with the values of the result columns named by the keys of `fields`, decoded by their types; it adds the fields to those selected earlier, replacing fields under their keys.
-   *
-   * A type of a column that can be `NULL` must be nullable.
-   * The statement rejects without a column of a field, or with the column twice; other columns are ignored.
-   */
-  select<S extends RecordSqlQueryState, F extends FieldTypes>(this: SqlQuery<S>, fields: F): SqlQuery<ChangeSqlQueryState<S, {
-    result: MergeSelection<ReturnedRecord<S>, DecodedFields<F>>;
-    rows: S["returned"];
-    value: false;
-    returning: true;
-  }>>;
-  /**
-   * Returns the value of the only column of the row of the statement instead of the number of the rows, decoded by `type`.
-   *
-   * Without a row, it rejects with `NotFoundError` unless `optional` makes the query resolve to `undefined`; it rejects several rows.
-   * A `NULL` value is `null`, so a type of a column that can be `NULL` must be nullable.
-   */
-  get<S extends SqlQueryState, T extends AnyType>(this: SqlQuery<S>, type: T): SqlQuery<ValueState<S, TypeOutput<T>, OneValueRows<S["returned"]>>>;
-  /**
-   * Returns the values of the only column of the rows of the statement instead of their number, decoded by `type`, keeping whether the query returns an array or one value.
-   *
-   * A `NULL` value is `null`, so a type of a column that can be `NULL` must be nullable.
-   */
-  pluck<S extends SqlQueryState, T extends AnyType>(this: SqlQuery<S>, type: T): SqlQuery<ValueState<S, TypeOutput<T>, ValueRows<S["returned"]>>>;
-  /**
-   * Returns the row of the statement instead of an array, and rejects with `NotFoundError` without it and with several rows; it adds no limit to the statement.
-   *
-   * Before a selection, the query resolves to the number of the rows, `1`, and rejects as well.
-   */
-  take<S extends SqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, OneRow<S["returned"]>>>;
-  /**
-   * Makes a query of one row, such as one of `take` or `get`, resolve to `undefined` without the row.
-   *
-   * Before a selection, the query resolves to `0` without the row.
-   */
-  optional<S extends OneRowSqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, "optional">>;
+  /** Marks a query of `transform`, for types only, so that TypeScript rejects a query of a table as one by this member, without comparing their states. */
+  readonly transformed: true;
+  /** `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: QueryNode, db?: AnyDb);
+  /** Converts the whole result further, after the earlier conversions; see `transform` of a query of a table. */
+  transform<S extends TransformedQueryState, Kind extends SelectQueryKind, R>(this: TransformedQuery<S, Kind>, callback: (result: QueryResult<S>) => R & SynchronousResult<R>): TransformedQuery<TransformedQueryState<S["table"], R, S["uses"]>, Kind>;
   /**
-   * Makes a query of one record, such as one of `take`, resolve to `null` without the row.
+   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
    *
-   * A value of `get` or `pluck` is never `null` for a missing row, which would read as a `NULL` value, so a query of values does not accept it.
-   * Before a selection, the query resolves to `0` without the row.
+   * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
    */
-  nullable<S extends OneRecordSqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, "nullable">>;
-  /** Compiles the query into SQL text and parameters, as its `Db` executes it. */
-  toSQL(): SqlStatement;
-  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+  toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /** Rejects the query as an operand of an expression, whose value SQL reads without its conversion. */
   [operandNode](): never;
-  /** Creates a query of the same `Db` with the node changes applied. */
-  private derive;
-  /** Creates the query that returns the value of the only column of each row in rows mode `rows`, decoded by `type` of `method`. */
-  private deriveValue;
-  /** Creates the query of one row in rows mode `rows`, rejecting a query of many rows. */
-  private changeOneRow;
 }
-/** Query of SQL text of any state. */
-type AnySqlQuery = SqlQuery<any>;
-/** Kind of a select query: `unbound`, or `bound` to a `Db`. */
-type SelectQueryKind = "unbound" | "bound";
-/**
- * `then` of a query of kind `Kind`: a bound query executes when awaited, and an unbound query is not thenable.
- *
- * Awaiting a query of either kind or returning it from an async function is a type error, since it may execute.
- */
-type QueryThen<S extends QueryState, Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? <R1 = QueryResult<S>, R2 = never>(onFulfilled?: ((result: QueryResult<S>) => R1 | PromiseLike<R1>) | null, onRejected?: ((reason: unknown) => R2 | PromiseLike<R2>) | null) => Promise<R1 | R2> : [Kind] extends ["unbound"] ? undefined : ((onFulfilled: never) => unknown) | undefined;
-/** `Db` of a query of kind `Kind`, which only a bound query has. */
-type QueryDb<Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? AnyDb : [Kind] extends ["unbound"] ? undefined : AnyDb | undefined;
-/** Arguments of `toSQL` of a query of kind `Kind`: a bound query compiles with the options of its `Db`. */
-type ToSQLArgs<Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? [] : [options?: CompileOptions];
-/** Query of any class, state, and kind: a select query of a table, a query of `$select`, one that inserts, updates, or deletes rows, or a query of SQL text. */
-type AnyQuery = AnySelectQuery | AnyRecordQuery | AnyMutationQuery | AnySqlQuery;
+/** Query of `transform` of a table of any state and kind. */
+type AnyTransformedQuery = TransformedQuery<any, SelectQueryKind>;
 /** Test fixture of `useTestFixture`, open while the tests of its `describe` block or test file run. */
 interface TestFixture<T = unknown> {
   /** Result of the seed of the fixture; reading it while the fixture is not open throws. */
@@ -1987,8 +2695,8 @@ interface BindOptions {
 type Db<T extends Tables, R extends SchemaRelations = EmptyRecord> = DbEntries<T, R> & DbMethods<T, R>;
 /** 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>;
+/** Bound or unbound query over a table of `T`, also converted by `transform`, 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>>> | TransformedQuery<TransformedQueryState<T[keyof T], unknown, UsableRelation<R>>, SelectQueryKind> | RecordQuery<RecordQueryState<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;
@@ -2215,6 +2923,8 @@ interface AggregateNode {
   readonly distinct: boolean;
   readonly arguments: readonly ExpressionNode[];
   readonly orderBy: readonly OrderNode[];
+  /** Condition of the rows that the function takes, as `FILTER (WHERE ...)`, or `undefined` for every row. */
+  readonly filter: ExpressionNode | undefined;
 }
 type ExpressionNode = ColumnRefNode | ParamNode | CastNode | BooleanNode | AndNode | OrNode | NotNode | ValuesNode | NestedQueryNode | ComparisonNode | InNode | InQueryNode | IsNullNode | RawSqlNode | TableNameNode | SubqueryNode | ExistsNode | TextSubqueryNode | AggregateNode;
 /**
@@ -2251,6 +2961,13 @@ interface OrderNode {
   readonly direction: "asc" | "desc";
   readonly nulls: "first" | "last" | undefined;
 }
+/** Lock of the rows that a select statement reads, in the words of PostgreSQL. */
+interface RowLockNode {
+  /** Strength of the lock, which follows `FOR`. */
+  readonly strength: "UPDATE" | "NO KEY UPDATE" | "SHARE" | "KEY SHARE";
+  /** What the statement does with a row that another transaction has locked, instead of waiting for it. */
+  readonly onLocked: "NOWAIT" | "SKIP LOCKED" | undefined;
+}
 /** Select query; its result mode applies only when it is executed or its rows are packed. */
 interface SelectNode<From extends SourceNode | undefined = SourceNode | undefined> extends ResultMode {
   readonly kind: "select";
@@ -2260,13 +2977,25 @@ interface SelectNode<From extends SourceNode | undefined = SourceNode | undefine
   /** Projections in the order of the result fields, with unique keys; a query without them returns records without fields. */
   readonly projections: readonly ProjectionNode[];
   readonly filters: QueryFilters;
+  /** Keys of `GROUP BY`, at least one; a key that a projection has is compiled as the position of the projection, whichever part of lowering adds it. */
+  readonly groupBy?: readonly ExpressionNode[] | undefined;
+  /** Condition of `HAVING`; it requires `groupBy`, which the semantic query checks. */
+  readonly having?: ExpressionNode | undefined;
   readonly orderBy: readonly OrderNode[];
   readonly limit: ExpressionNode | undefined;
   readonly offset: ExpressionNode | undefined;
+  /** Whether the query removes the duplicates of its rows, as `SELECT DISTINCT`; it requires a projection, as PostgreSQL does. */
+  readonly distinct?: boolean | undefined;
+  /** Keys of `DISTINCT ON`, at least one, whose equal values give one row, the first in the order; a key that a projection has is compiled as the position of the projection, as a key of `groupBy` is. */
+  readonly distinctOn?: readonly ExpressionNode[] | undefined;
+  /** Lock of the rows of the source of the statement, which does not reach the subqueries of its other clauses; it requires a source of rows, as PostgreSQL does. */
+  readonly lock?: RowLockNode | 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;
+  /** How code converts the decoded result of the query; see `ResultPlan`. */
+  readonly conversion?: ResultConversion | undefined;
 }
 /** Assignment of `SET` of an update: the value of the column under `key`. */
 interface AssignmentNode {
@@ -2283,6 +3012,8 @@ interface MutationParts<Field> extends ResultMode {
   readonly returning: readonly Field[] | undefined;
   /** Template of the records of a mutation with literals; see `ResultPlan`. */
   readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
+  /** How code converts the decoded result of the mutation; see `ResultPlan`. */
+  readonly conversion?: ResultConversion | undefined;
 }
 /** Insert statement of rows of `VALUES`. */
 interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
@@ -2355,13 +3086,13 @@ 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>;
@@ -2398,140 +3129,47 @@ declare const textOperators: TextOperators;
 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>;
-/** 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>>;
-/**
- * Returns the first of its operands other than `NULL`, such as `coalesce(field.hint, "")`, as an expression usable wherever a column is.
- *
- * `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.
- */
-declare function coalesce<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
-/**
- * Returns the largest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
- *
- * `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`.
- */
-declare function greatest<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
-/**
- * Returns the smallest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
- *
- * `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`.
- */
-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>;
-/**
- * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `NULL` when none holds.
- *
- * `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 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>;
-/**
- * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `otherwise` when none holds.
- *
- * `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 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 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.
- *
- * It is guaranteed, so that the state that the callback returns tells whether the callback ends the guarantee of the query the helper is applied to.
- */
-interface HelperState<T extends AnyTable, C extends SchemaContext> extends QueryStateOf<T, C> {
-  readonly result: HelperFields<never>;
-  readonly valueType: never;
-  readonly rows: "many";
-  readonly value: false;
-  readonly uses: never;
-  readonly guaranteed: true;
-  readonly aggregate: false;
-}
 /**
- * Effect of a helper: the fields it selects, its rows mode on a query of many rows, `one` after `take` or `required` and `nullable` or `optional` after the method of the same name, the relations it selects records of, and whether it keeps the guarantee of the row of a query of a required relation.
+ * 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.
  *
- * `reads` are the relations of the schema of the helper among them, which its callback may read from the references of the query it is applied to, and `key` is the key of its table there.
+ * `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`.
  */
-interface HelperEffect {
-  readonly fields: object;
-  readonly rows: ResultRows;
-  readonly uses: UsedRelation;
-  readonly reads: UsedRelation;
-  readonly key: string;
-  readonly guaranteed: boolean;
-}
-/** Effect of a helper whose callback returns a query of state `S`, for each state of a union. */
-type ReadEffect<S extends SelectQueryState> = S extends SelectQueryState ? {
-  readonly fields: { [K in keyof S["result"] as K extends keyof HelperFields ? never : K]: S["result"][K]; };
-  readonly rows: S["rows"];
-  readonly uses: S["uses"];
-  readonly reads: Extract<UsableRelation<S["schema"]["relations"]>, S["uses"]>;
-  readonly key: S["schema"]["key"];
-  readonly guaranteed: S["guaranteed"];
-} : never;
-/** Error of a helper that a query does not accept, or whose callback returns a query it does not accept. */
-interface HelperError<Message extends string> {
-  readonly error: Message;
-}
-/** `unknown` when every result state retains the input marker and returns records, or the error. */
-type CheckResult<S extends SelectQueryState> = [S] extends [{
-  readonly result: HelperFields;
-  readonly value: false;
-}] ? unknown : HelperError<"A helper can filter, select fields, and take one row, but cannot clear the selection or use get, pluck, or aggregates">;
-/** State of a query over table `T` that accepts a helper of effect `E`. */
-type HelperInput<T extends AnyTable, E extends HelperEffect> = QueryStateOf<T, ReadsContext<E>> & ValueCheck<E>;
-/** Constraint of `value` of a query that accepts a helper of effect `E`. */
-type ValueCheck<E extends HelperEffect> = [E extends HelperEffect ? keyof E["fields"] : never] extends [never] ? [Extract<E["rows"], "nullable">] extends [never] ? unknown : RecordRows<"A helper cannot apply nullable to a query made by get, pluck, or an aggregate"> : RecordRows<"A helper cannot select fields on a query made by get, pluck, or an aggregate">;
-/** Constraint of a query whose rows are records, which a query of values fails with error `Message`. */
-interface RecordRows<Message extends string> {
-  readonly value: false | HelperError<Message>;
+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;
 }
-/** Schema context of a query that has the relations of its schema that a helper of effect `E` may read. */
-type ReadsContext<E extends HelperEffect> = [E["reads"]] extends [never] ? SchemaContext : SchemaContext<{ readonly [K in E["reads"]["key"]]: { readonly [N in Extract<E["reads"], {
-  readonly key: K;
-}>["name"]]: Extract<E["reads"], {
-  readonly key: K;
-  readonly name: N;
-}>["relation"]; }; }, E["key"]>;
-/** State of a query of state `S` after a helper of effect `E`. */
-type ApplyEffect<S extends SelectQueryState, E extends HelperEffect> = ChangeState<S, {
-  result: [keyof E["fields"]] extends [never] ? S["result"] : MergeSelection<S["result"], E["fields"]>;
-  rows: E["rows"] extends "many" ? EffectRows<S, E> : E["rows"] extends "one" ? OneRow<EffectRows<S, E>> : E["rows"];
-  uses: S["uses"] | E["uses"];
-  guaranteed: E["guaranteed"] extends true ? S["guaranteed"] : false;
-}>;
-/** Rows mode of a query of state `S` after a helper of effect `E` that keeps the rows, before `take`: relaxed as after a filter when the helper ends the guarantee. */
-type EffectRows<S extends SelectQueryState, E extends HelperEffect> = E["guaranteed"] extends true ? S["rows"] : FilteredStateRows<S>;
+/** 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);
 /**
- * Helper of `defineHelper` for queries over table `T`: it applies effect `E` to the query it receives with arguments `A` and returns a query of the same kind.
+ * Check of object `V` of `matches` against references `R`, which gives each of its keys the value of its column.
  *
- * Selected fields replace earlier fields under the same keys; a query made by `get`, `pluck`, or an aggregate method does not accept a helper that selects fields.
+ * 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 Helper<T extends AnyTable, E extends HelperEffect, A extends unknown[]> = <S extends HelperInput<T, E>, Kind extends SelectQueryKind>(query: SelectQuery<S, Kind>, ...args: A) => E extends HelperEffect ? SelectQuery<ApplyEffect<S, E>, Kind> : never;
+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);
 /**
- * Defines a reusable helper of a table that filters, selects fields, and applies `take`, `optional`, `nullable`, and `required`, used with `use` or called with a query.
+ * 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 })`.
  *
- * `helper` receives the query it is applied to and any further arguments, and returns the query with its clauses.
- * Defined with a query of a schema, such as `schema.form`, it can select the relations of the table in that schema, and applies to queries whose schema has them.
- * The helper returns a query of the same kind as the one it is applied to, bound to the same `Db` if any.
+ * 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 defineHelper<T extends AnyTable, R extends SelectQuery<any, SelectQueryKind>, A extends unknown[], C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, helper: (query: SelectQuery<HelperState<T, C>, SelectQueryKind>, ...args: A) => R & CheckResult<R["types"]>): Helper<T, ReadEffect<R["types"]>, A>;
+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>>;
 /** Tagged template building a SQL fragment of values `T` that accepts compared values `I`. */
 type SqlTemplate<T, O extends OperatorDefinitions, I = T> = (strings: TemplateStringsArray, ...values: unknown[]) => Expression<T, O, I>;
 /**
@@ -2568,4 +3206,10 @@ 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 { SelectQueryKind as $, QueryStateOf as $n, OperatorSignature as $r, from as $t, Expression as A, WhereValues as An, TransactionFailure as Ar, Schema as At, Database as B, ColumnRefs as Bn, TypeTransform as Br, EqualityOperator as Bt, TextOperators as C, KeyCheck as Cn, ResultDecodeError as Cr, TableContext as Ct, orderingOperators as D, WhereCallback as Dn, Driver as Dr, many as Dt, NumberTypeOperators as E, EqValue as En, Connection as Er, UsedRelation as Et, BindOptions as F, Predicate as Fn, Type as Fr, defineSchema as Ft, OpenedTestFixture as G, OneValueRows as Gn, KeyKind as Gr, AnySelectQuery as Gt, TransactionOptions as H, RelationRefs as Hn, AnyColumn as Hr, HasEquality as Ht, Db as I, and as In, TypeInput as Ir, AnyRecordQuery as It, TestHelpers as J, ValueRows as Jn, MergeOperators as Jr, ResultOf as Jt, PendingTestFixture as K, QueryResult as Kn, ToColumn as Kr, BoundSelectQuery as Kt, DbMutationState as L, not as Ln, TypeOperators as Lr, RecordQuery as Lt, TypedExpression as M, CombinedCondition as Mn, AnyType as Mr, SchemaPartRelations as Mt, UntypedExpression as N, Condition as Nn, BaseType as Nr, SchemaTables as Nt, AnyExpression as O, WhereCondition as On, DriverResult as Or, one as Ot, AnyDb as P, ConditionOperand as Pn, TextValue as Pr, Tables as Pt, AnyQuery as Q, QueryState as Qn, GenericOperatorImplementation as Qr, ValuesQuery as Qt, DbOf as R, or as Rn, TypeOptions as Rr, RecordQueryState as Rt, TextLengthSignature as S, orderBy as Sn, RequiredRelationError as Sr, SchemaRelations as St, textOperators as T, PrimaryKeyValues as Tn, ResultRows as Tr, UsableRelation as Tt, createDatabase as U, FilteredRows as Un, Column as Ur, InSignature as Ut, DatabaseOptions as V, QueryContext as Vn, defineType as Vr, EqualityOperators as Vt, TransactionCoordinator as W, OneRow as Wn, ColumnAttributes as Wr, equalityOperators as Wt, TestTransactionOptions as X, EmptyRecord as Xn, OperatorDefinitions as Xr, SelectQuery as Xt, TestHooks as Y, CountValueType as Yn, NoOperators as Yr, ScalarQuery as Yt, createTestHelpers as Z, InitialQueryState as Zn, GenericOperator as Zr, TypedScalarQuery as Zt, least as _, OrderTerms as _n, TableKeys as _r, RelationKey as _t, Helper as a, ExpressionValue as an, OperandValue as ar, SqlQueryState as at, PatternSignature as b, asc as bn, defineTable as br, RequiredMember as bt, CaseBranch as c, Selection as cn, AnyTable as cr, MutationQuery as ct, FollowingOperand as d, Literal as dn, ColumnOperators as dr, MergeRelations as dt, defineGenericOperator as ei, ColumnValue as en, QueryValueType as er, AnySqlQuery as et, NullSkippingResult as f, literal as fn, ColumnShape as fr, NoRelations as ft, greatest as g, OrderTerm as gn, Table as gr, RelationDeclarations as gt, coalesce as h, OrderKey as hn, Selectable as hr, RelationDeclaration as ht, sql as i, ExpressionInput as in, Operand as ir, SqlQuery as it, ExpressionOperators as j, defineFilter as jn, createStatement as jr, SchemaPart as jt, BaseOperators as k, WhereFilter as kn, SqlStatement as kr, AnySchema as kt, CaseCondition as l, SelectionResult as ln, AnyTableKeys as lr, MutationQueryState as lt, caseWhen as m, OrderDirection as mn, KeyColumns as mr, Relation as mt, identifier as n, UpdateSet as nn, BooleanResult as nr, FieldTypes as nt, HelperEffect as o, MergeSelection as on, compare as or, AnyMutationQuery as ot, TypedOperand as p, OrderColumns as pn, ColumnValues as pr, OneRelationKeys as pt, TestFixture as q, ResultByRows as qn, BoundOperators as qr, FilteredStateRows as qt, param as r, UpdateValues as rn, ComparisonSignature as rr, InitialSqlQueryState as rt, defineHelper as s, NestedQuery as sn, CompileOptions as sr, InitialMutationState as st, SqlTemplate as t, InsertValues as tn, SelectQueryState as tr, DecodedFields as tt, CaseValue as u, SelectionUses as un, ColumnDefinitions as ur, DeclaredRelations as ut, FALSE as v, Ordering as vn, TableOptions as vr, RelationKeys as vt, TextTypeOperators as w, NotAKey as wn, ResultMode as wr, TableRelations as wt, TextConversionSignature as x, desc as xn, NotFoundError as xr, SchemaContext as xt, TRUE as y, SelectedRefs as yn, ToColumns as yr, RelationKind as yt, DbQueryState as z, ExistsValueType as zn, TypeOutput as zr, SelectionState as zt };
+/**
+ * Converts a column key to snake case, such as `form_id` for `formId`, for the `columnName` option of `createTableFactory`.
+ *
+ * A run of capital letters is one word, such as `user_id` for `userID`, and digits stay in their word, such as `line2`.
+ */
+declare function toSnakeCase(key: string): string;
+export { NoRelations as $, UpdateSet as $n, AnyTableKeys as $r, least as $t, Db as A, TypeOptions as Ai, some as An, CompileOptions as Ar, DecodedFields as At, PendingTestFixture as B, MergeOperators as Bi, asc as Bn, compare as Br, HelperEffect as Bt, BaseOperators as C, createStatement as Ci, UnfilteredStringAggOptions as Cn, FilteredRows as Cr, AnyRecordQuery as Ct, UntypedExpression as D, Type as Di, every as Dn, ResultByRows as Dr, AnyQuery as Dt, TypedExpression as E, TextValue as Ei, countDistinct as En, QueryResult as Er, SelectionState as Et, DatabaseOptions as F, Column as Fi, OrderKey as Fn, equalityOperators as Fr, AnyMutationQuery as Ft, createTestHelpers as G, OperatorSignature as Gi, RelationRefs as Gn, EmptyRecord as Gr, FollowingOperand as Gt, TestHelpers as H, OperatorDefinitions as Hi, orderBy as Hn, ScalarQuery as Hr, CaseBranch as Ht, TransactionOptions as I, ColumnAttributes as Ii, OrderTerm as In, BooleanResult as Ir, InitialMutationState as It, SynchronousResult as J, ResultOf as Jn, QueryState as Jr, TypedOperandInput as Jt, AnyTransformedQuery as K, defineGenericOperator as Ki, AnySelectQuery as Kn, Grouped as Kr, NullSkippingResult as Kt, createDatabase as L, KeyKind as Li, OrderTerms as Ln, ComparisonSignature as Lr, MutationQuery as Lt, DbOf as M, TypeTransform as Mi, sum as Mn, EqualityOperators as Mr, InitialSqlQueryState as Mt, DbQueryState as N, defineType as Ni, OrderColumns as Nn, HasEquality as Nr, SqlQuery as Nt, AnyDb as O, TypeInput as Oi, max as On, ValueRows as Or, SelectQueryKind as Ot, Database as P, AnyColumn as Pi, OrderDirection as Pn, InSignature as Pr, SqlQueryState as Pt, MergeRelations as Q, InsertValues as Qn, AnyTable as Qr, greatest as Qt, TransactionCoordinator as R, ToColumn as Ri, Ordering as Rn, Operand as Rr, MutationQueryState as Rt, AnyExpression as S, TransactionFailure as Si, UnfilteredAggregateOptions as Sn, ExistsValueType as Sr, defineSchema as St, ExpressionOperators as T, BaseType as Ti, count as Tn, OneValueRows as Tr, RecordQueryState as Tt, TestHooks as U, GenericOperator as Ui, ColumnRefs as Un, TypedScalarQuery as Ur, CaseCondition as Ut, TestFixture as V, NoOperators as Vi, desc as Vn, OperandUses as Vr, defineHelper as Vt, TestTransactionOptions as W, GenericOperatorImplementation as Wi, QueryContext as Wn, ValuesQuery as Wr, CaseValue as Wt, TransformedQueryState as X, from as Xn, QueryValueType as Xr, caseWhen as Xt, TransformedQuery as Y, SelectQuery as Yn, QueryStateOf as Yr, TypedOperandOperators as Yt, DeclaredRelations as Z, ColumnValue as Zn, SelectQueryState as Zr, coalesce as Zt, TextOperators as _, ResultRows as _i, AggregateOptions as _n, ConditionOperand as _r, Schema as _t, sql as a, Selectable as ai, GroupedField as an, GroupTerm as ar, RelationKeys as at, NumberTypeOperators as b, DriverResult as bi, GroupValue as bn, not as br, SchemaTables as bt, MatchResult as c, TableKeys as ci, NestedQuery as cn, NotAKey as cr, SchemaContext as ct, defineExpression as d, createTableFactory as di, SelectionFieldTypes as dn, WhereCallback as dr, TableRelations as dt, ColumnDefinitions as ei, ColumnFieldTypes as en, UpdateValues as er, OneRelationKeys as et, FALSE as f, defineTable as fi, SelectionResult as fn, WhereCondition as fr, UsableRelation as ft, TextLengthSignature as g, ResultMode as gi, AggregateExpression as gn, Condition as gr, AnySchema as gt, TextConversionSignature as h, ResultDecodeError as hi, literal as hn, CombinedCondition as hr, one as ht, param as i, KeyColumns as ii, GroupSelectionResult as in, RowLockOptions as ir, RelationKey as it, DbMutationState as j, TypeOutput as ji, stringAgg as jn, EqualityOperator as jr, FieldTypes as jt, BindOptions as k, TypeOperators as ki, min as kn, CountValueType as kr, AnySqlQuery as kt, NotAColumn as l, TableOptions as li, SelectedFieldTypes as ln, PrimaryKeyValues as lr, SchemaRelations as lt, PatternSignature as m, RequiredRelationError as mi, Literal as mn, WhereValues as mr, many as mt, SqlTemplate as n, ColumnShape as ni, ExpressionValue as nn, GroupedState as nr, RelationDeclaration as nt, ColumnRefKey as o, Table as oi, GroupedRecord as on, GroupTerms as or, RelationKind as ot, TRUE as p, NotFoundError as pi, SelectionUses as pn, WhereFilter as pr, UsedRelation as pt, NotSynchronous as q, BoundSelectQuery as qn, InitialQueryState as qr, TypedOperand as qt, identifier as r, ColumnValues as ri, GroupOperandValue as rn, SelectedOperandType as rr, RelationDeclarations as rt, MatchCheck as s, TableFactoryOptions as si, MergeSelection as sn, KeyCheck as sr, RequiredMember as st, toSnakeCase as t, ColumnOperators as ti, ExpressionInput as tn, FilteredStateRows as tr, Relation as tt, matches as u, ToColumns as ui, Selection as un, EqValue as ur, TableContext as ut, TextTypeOperators as v, Connection as vi, CountExpression as vn, Predicate as vr, SchemaPart as vt, Expression as w, AnyType as wi, avg as wn, OneRow as wr, RecordQuery as wt, orderingOperators as x, SqlStatement as xi, StringAggOptions as xn, or as xr, Tables as xt, textOperators as y, Driver as yi, GroupAggregateExpression as yn, and as yr, SchemaPartRelations as yt, OpenedTestFixture as z, BoundOperators as zi, SelectedRefs as zn, OperandValue as zr, Helper as zt };