kern-orm 0.5.0 → 0.7.0

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

@@ -49,7 +49,7 @@ type BoundOperators<O extends OperatorDefinitions, T, I = T> = { [K in keyof O]:
 /** Kind of a key of a table: its primary key, or a unique key. */
 type KeyKind = "primaryKey" | "unique";
 /**
- * Type that `primaryKey()` of a type or a column whose values may be `null` is checked against, naming the reason.
+ * Type that `primaryKey()` of a type or a column that accepts `null` is checked against, naming the reason.
  *
  * Without `strictNullChecks`, `null` belongs to every type, so every column looks nullable; the type then names the option instead.
  */
@@ -86,7 +86,7 @@ declare class Column<T extends AnyType, Key extends KeyKind | undefined = KeyKin
   /** Uses a physical column name different from the column key. */
   columnName(name: string): Column<T, Key, Default>;
   /** Marks the column as the primary key; the type must not be nullable. */
-  primaryKey(this: null extends TypeOutput<T> ? NullablePrimaryKey : Column<T, undefined, Default>): Column<T, "primaryKey", Default>;
+  primaryKey(this: null extends TypeInput<T> ? NullablePrimaryKey : Column<T, undefined, Default>): Column<T, "primaryKey", Default>;
   /** Marks the column as a unique key. */
   unique(this: Column<T, undefined, Default>): Column<T, "unique", Default>;
   /** Marks the column as one that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
@@ -148,19 +148,26 @@ interface BaseType<Output, Input, Operators extends OperatorDefinitions, Paramet
   withParameters<P extends unknown[]>(format: (...parameters: P) => string): Type<Output, Input, Operators, P>;
   /**
    * Creates a type with another representation of the values of this type, keeping its SQL type, operators, and nullability.
+   * An `encode` that takes `null` also makes the result nullable.
    *
    * `decode` receives the values that this type decodes from values other than `NULL`, including `undefined` that an earlier decoder returns, and returns a value other than `null`; `encode` returns values that this type encodes; `NULL` stays `null` without them.
    */
-  transform<NewOutput extends {} | undefined, NewInput>(options: TypeTransform<Exclude<Output, null>, NonNullable<Input>, NewOutput, NewInput>): Type<NewOutput | Extract<Output, null>, NewInput | Extract<Input, null>, Operators, Parameters>;
+  transform<NewOutput extends {} | undefined, NewInput>(options: TypeTransform<Exclude<Output, null>, NonNullable<Input>, NewOutput, NewInput>): Type<NewOutput | AcceptedNull<NewInput | Input>, NewInput | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a type that decodes the values of this type into another representation, other than `null`, and accepts the values that this type accepts. */
   transform<NewOutput extends {} | undefined>(options: {
     decode: (value: Exclude<Output, null>) => NewOutput;
-  }): Type<NewOutput | Extract<Output, null>, Input, Operators, Parameters>;
+  }): Type<NewOutput | AcceptedNull<Input>, Input, Operators, Parameters>;
   nullable(): Type<Output | null, Input | null, Operators, Parameters>;
+  /**
+   * Narrows the values of this type to `T` in TypeScript, such as to a union of strings that a `CHECK` constraint allows, or to the shape of JSON values.
+   *
+   * The values are not validated at runtime. `T` must be among the values that this type both returns and accepts, and `nullable` keeps `null` apart from it.
+   */
+  of<T extends AcceptedValues<Exclude<Output, null>, Exclude<Input, null>>>(): Type<T | AcceptedNull<Input>, T | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a column of this type with a physical name different from the column key. */
   columnName(name: string): Column<Type<Output, Input, Operators, Parameters>, undefined, false>;
   /** Creates a primary key column of this type; the type must not be nullable. */
-  primaryKey(this: null extends Output ? NullablePrimaryKey : Type<Output, Input, Operators, Parameters>): Column<Type<Output, Input, Operators, Parameters>, "primaryKey", false>;
+  primaryKey(this: null extends Input ? NullablePrimaryKey : Type<Output, Input, Operators, Parameters>): Column<Type<Output, Input, Operators, Parameters>, "primaryKey", false>;
   /** Creates a column of this type that is a unique key. */
   unique(): Column<Type<Output, Input, Operators, Parameters>, "unique", false>;
   /** Creates a column of this type that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
@@ -171,6 +178,18 @@ interface TypeWithParameters<Output, Input, Operators extends OperatorDefinition
   /** Creates this type with PostgreSQL type parameters, such as `varchar.with(255)` for `varchar(255)`; other changes of the type are kept. */
   with(...parameters: Parameters): Type<Output, Input, Operators, Parameters>;
 }
+/**
+ * Values that `of` can narrow a type to: those both among the values `O` that it returns and among the values `I` that it accepts, or `UnacceptedValues` when there are none.
+ *
+ * A narrowed value is also accepted, so its encoder must take it.
+ */
+type AcceptedValues<O, I> = [O] extends [I] ? O : [I] extends [O] ? I : [O & I] extends [never] ? UnacceptedValues : O & I;
+/** `null` when the accepted values `I` include it, also as `unknown`; `never` otherwise. */
+type AcceptedNull<I> = null extends I ? null : never;
+/** Type that `AcceptedValues` names for a type that accepts none of the values it returns. */
+interface UnacceptedValues {
+  readonly "of narrows only a type that accepts the values it returns": never;
+}
 /** Conversion between the values of a type and their new representation. */
 interface TypeTransform<Output, Input, NewOutput, NewInput> {
   decode: (value: Output) => NewOutput;
@@ -209,9 +228,9 @@ interface SqlStatement {
 declare function createStatement(text: string, parameters?: readonly TextValue[]): SqlStatement;
 /** Result of a statement. */
 interface DriverResult {
-  /** Command of the tag that PostgreSQL completed the statement with, such as `SELECT` or `ROLLBACK` for a `COMMIT` of a failed transaction; a driver may give only the first word of a tag of several words, such as `CREATE` of `CREATE TABLE`. */
-  readonly command: string;
-  /** Number of rows that the command tag reports, such as the rows that an `UPDATE` changes, also without `RETURNING`; `0` for a command without one, such as `BEGIN`. */
+  /** 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[];
@@ -230,7 +249,11 @@ interface Driver {
   executeScript(text: string): Promise<void>;
   /** Reserves a dedicated connection, such as for a transaction. */
   acquire(): Promise<Connection>;
-  /** Closes the connections once the transactions on reserved connections end. */
+  /**
+   * Closes the connections once the statements on the pool and the transactions on reserved connections end.
+   *
+   * From the call, it rejects a new statement or script on the pool and a new connection.
+   */
   close(): Promise<void>;
 }
 /** Connection reserved by a driver, such as for a transaction. */
@@ -278,6 +301,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 +333,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 +360,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. */
@@ -366,21 +408,23 @@ interface TableKeys<PrimaryKey extends KeyColumns | undefined, UniqueKey extends
   readonly [keysType]: (primaryKey: PrimaryKey, unique: UniqueKey) => readonly [PrimaryKey, UniqueKey];
 }
 /**
- * Immutable table descriptor: physical name, columns, and keys.
+ * Immutable table descriptor: physical name, columns, keys, and whether it holds at most one row.
  *
  * A table knows nothing about relations, schemas, or database connections, so the same table can belong to several schemas.
  * Its object identity is the logical identity of the table.
  */
-interface Table<Name extends string = string, Columns extends ColumnShape = ColumnShape, Keys extends AnyTableKeys = AnyTableKeys> {
+interface Table<Name extends string = string, Columns extends ColumnShape = ColumnShape, Keys extends AnyTableKeys = AnyTableKeys, Singleton extends boolean = boolean> {
   readonly kind: "table";
   readonly name: Name;
   readonly columns: Columns;
   readonly keys: Keys;
+  /** Whether the table holds at most one row, as the `singleton` option of `defineTable` declares; `boolean` where the type of the table does not tell it. */
+  readonly singleton: Singleton;
 }
 /** Table of any name, columns, and keys. */
 type AnyTable = Table<string, ColumnShape>;
 /**
- * Options of `defineTable` over column keys `Column`: the keys of several columns, whose columns are listed in their order.
+ * Options of `defineTable` over column keys `Column`: the keys of several columns, whose columns are listed in their order, and whether the table holds at most one row.
  *
  * The columns of the primary key are of `PrimaryKeyColumn`.
  */
@@ -389,6 +433,17 @@ interface TableOptions<Column extends string = string, PrimaryKeyColumn extends
   readonly primaryKey?: readonly [PrimaryKeyColumn, PrimaryKeyColumn, ...PrimaryKeyColumn[]];
   /** Unique keys of several columns; mark a unique key of one column with `unique()`. */
   readonly unique?: readonly (readonly [Column, Column, ...Column[]])[];
+  /**
+   * Whether the table holds at most one row, such as the settings of an application, which a unique index of `(true)` must guarantee.
+   *
+   * A query of the table starts as a query of that row, which resolves to `undefined` without it, and `upsert` inserts or updates it.
+   */
+  readonly singleton?: boolean;
+}
+/** 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"]>; };
@@ -415,8 +470,8 @@ type MatchingKey$1<Key, Columns> = Key extends KeyColumns ? [Key[number]] extend
 type IncludedKey<Key, Columns> = Key extends KeyColumns ? [Key[number]] extends [Columns] ? true : never : never;
 /** Column key of columns `C` as a string, as object keys are at runtime. */
 type ColumnKey<C extends ColumnShape> = `${keyof C & (string | number)}`;
-/** Column key of columns `C` whose type is not nullable, as a string like `ColumnKey`. */
-type NonNullableColumnKey<C extends ColumnShape> = { [K in keyof C]: null extends TypeOutput<C[K]["type"]> ? never : `${K & (string | number)}`; }[keyof C];
+/** Column key of columns `C` whose type does not accept `null`, as a string like `ColumnKey`. */
+type NonNullableColumnKey<C extends ColumnShape> = { [K in keyof C]: null extends TypeInput<C[K]["type"]> ? never : `${K & (string | number)}`; }[keyof C];
 /** Column key of columns `C`, as a string like `ColumnKey`, whose column forms a key of kind `Kind` alone, as `KnownKeyKind` tells. */
 type KeyedColumn<C extends ColumnShape, Kind> = { [K in keyof C]: KnownKeyKind<C[K]["attributes"]["keyKind"]> extends Kind ? `${K & (string | number)}` : never; }[keyof C];
 /** Kind `Kind` of the key that a column forms alone, or `"unknown"` where the type of the column does not tell it. */
@@ -438,6 +493,8 @@ type KnownKeysOf<PrimaryKey extends KeyColumns | undefined, UniqueKey extends Ke
 type DefinedPrimaryKey<C extends ColumnShape, PrimaryKey> = PrimaryKey extends KeyColumns ? PrimaryKey : [KeyedColumn<C, "primaryKey">] extends [never] ? undefined : SingleColumnKey<KeyedColumn<C, "primaryKey">>;
 /** Unique key of a table of columns `C`: `UniqueKey` of its options, or of a column marked with `unique()`. */
 type DefinedUniqueKey<C extends ColumnShape, UniqueKey> = Extract<UniqueKey, KeyColumns> | SingleColumnKey<KeyedColumn<C, "unique">>;
+/** Whether a table of options `O` holds at most one row: `true` or `false` of their `singleton`, `false` without it, or `boolean` where its type does not tell it. */
+type DefinedSingleton<O> = O extends unknown ? [O["singleton" & keyof O]] extends [false | undefined] ? false : [O["singleton" & keyof O]] extends [true] ? true : boolean : never;
 /** Key of each single column of `K`. */
 type SingleColumnKey<K> = K extends string ? readonly [K] : never;
 /** Primary key in options `O`: `undefined` without one, or `"unknown"` where its type does not tell it. */
@@ -455,70 +512,33 @@ type IsExactKey<K> = true extends IsUnion<K> ? false : K extends readonly unknow
  *
  * A key of one column is marked on its column.
  */
-declare function defineTable<Name extends string, Definitions extends ColumnDefinitions>(name: Name, definitions: Definitions): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, undefined>>;
+declare function defineTable<Name extends string, Definitions extends ColumnDefinitions>(name: Name, definitions: Definitions): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, undefined>, false>;
 /**
  * Defines a table; a type without column attributes becomes a column as it is.
  *
- * 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;
-}
-/**
- * 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.
- */
-type Operand<T, I = T> = NonNullable<I> | AnyExpression<NonNullable<T> | null> | ScalarQuery<NonNullable<T> | null>;
-/** SQL value of an operand, unwrapping an expression or a query. */
-type OperandValue<V> = V extends AnyExpression<infer T> ? T : V extends ScalarQuery ? ScalarQueryValue<V> : V;
-/** Boolean result that can be NULL when an input value can be NULL. */
-type BooleanResult<T> = boolean | (null extends T ? null : never);
-/** Signature of a generic operator comparing an expression with an operand of its type, such as `lt`. */
-interface ComparisonSignature extends OperatorSignature {
-  readonly method: <V extends Operand<this["T"], this["I"]>>(value: V) => Expression<BooleanResult<this["T"] | OperandValue<V>>>;
-}
-/**
- * Compares an expression with a value, another expression, or a query of one value, encoding a plain value with the type of the expression.
- *
- * Operators of custom types build comparisons with it, such as `compare(self, "ILIKE", pattern)`.
+ * A key of one column is marked on its column, and `options` list the columns of the keys of several columns and tell whether the table holds at most one row.
  */
-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;
+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>, DefinedSingleton<Options>>;
 /**
- * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+ * Creates a table-definition function with the given naming convention, for an application to define its tables with.
  *
- * 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 `=`.
+ * Its tables have the same types as those of `defineTable`.
  */
-declare const equalityOperators: EqualityOperators;
+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 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`. */
+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;
 }
@@ -528,7 +548,7 @@ interface QueryValueType {
   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.
+ * 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.
  */
@@ -537,6 +557,8 @@ interface SelectQueryState extends QueryState {
   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`.
    *
@@ -544,7 +566,7 @@ interface SelectQueryState extends QueryState {
    * 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. */
+  /** 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. */
@@ -560,12 +582,129 @@ interface QueryStateOf<T extends AnyTable, C extends SchemaContext = SchemaConte
 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;
 }
+/**
+ * State of a query that starts from table `T` with schema context `C`, as the entry points of a schema and a `Db` and `from` start it: of all the rows of the table, or of the one row of a singleton table.
+ *
+ * Where the type of `T` does not tell whether it is a singleton, such as `Table<Name, Columns>`, it is the union of both.
+ */
+type TableQueryState<T extends AnyTable, C extends SchemaContext = NoRelations> = SingletonOrInitialState<T, C, T["singleton"]>;
+/** State of a query that starts from table `T` with schema context `C`, as `TableQueryState` gives it, by `Singleton`, the `singleton` of the type of `T`. */
+type SingletonOrInitialState<T extends AnyTable, C extends SchemaContext, Singleton> = Singleton extends true ? SingletonQueryState<T, C> : InitialQueryState<T, C>;
+/** State of a query that starts from singleton table `T` with schema context `C`: its one row as a record without fields, which resolves to `undefined` without it. */
+interface SingletonQueryState<T extends AnyTable, C extends SchemaContext = NoRelations> extends InitialQueryState<T, C, never, "optional">, FoundKey<never> {}
+/** Key of the member of `FoundKey` that makes it invariant in the columns of the key. */
+declare const foundKeyVariance: unique symbol;
+/** Part of the state of a query of `find` or `findBy` with the columns `K` of its key, or of a query of a singleton table without them, which `upsert` applies to. */
+interface FoundKey<K extends string> {
+  readonly foundKey: K;
+  readonly [foundKeyVariance]: { readonly [C in K]: true; };
+}
+/** 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.
+ */
+type Operand<T, I = T> = NonNullable<I> | AnyExpression<NonNullable<T> | null> | ScalarQuery<NonNullable<T> | null>;
+/** SQL value of an operand, unwrapping an expression or a query. */
+type OperandValue<V> = V extends AnyExpression<infer T> ? T : V extends ScalarQuery ? ScalarQueryValue<V> : V;
+/** Boolean result that can be NULL when an input value can be NULL. */
+type BooleanResult<T> = boolean | (null extends T ? null : never);
+/** Signature of a generic operator comparing an expression with an operand of its type, such as `lt`. */
+interface ComparisonSignature extends OperatorSignature {
+  readonly method: <V extends Operand<this["T"], this["I"]>>(value: V) => Expression<BooleanResult<this["T"] | OperandValue<V>>>;
+}
+/**
+ * Compares an expression with a value, another expression, or a query of one value, encoding a plain value with the type of the expression.
+ *
+ * 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;
@@ -591,13 +730,37 @@ 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;
+  /**
+   * Values of the columns of the key of `find` or `findBy` of a query of a table without clauses, which `upsert` inserts, an empty object for a query that starts from a singleton table, whose key has no columns, or `undefined` for any other query.
+   *
+   * Every method that derives a node from the query drops them, whereas `use` returns the query of its callback, such as the query itself.
+   */
+  readonly foundKey: Readonly<Record<string, unknown>> | 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.
@@ -611,31 +774,25 @@ interface RecordQueryNode {
   /** Fields in the order of the record, with unique keys. */
   readonly projections: readonly SelectedNode[];
 }
-/**
- * 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;
+/** 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>>;
+}>, undefined>;
+/** Type of the value of a query of a count. */
+interface CountValueType extends QueryValueType {
+  readonly input: TypeInput<typeof countType>;
+  readonly operators: TypeOperators<typeof countType>;
 }
-/**
- * Creates a field of a selection with `value` in every record, without selecting anything in SQL: the query returns the value itself, not a copy of it, whatever it is.
- *
- * It lets a branch of a selection skip a column or a nested query, such as `withHint ? field.hint : literal(null)`.
- * To use a value in SQL, such as in a condition, pass it through `param` instead.
- */
-declare function literal<T extends {} | null | undefined>(value: T): Literal<T>;
 /** Rows mode of a query of a relation of kind `Kind`: `many`, or one row, `nullable` unless `Required` is `true`; a union gives the union of their modes. */
 type RelationRows<Kind extends RelationKind, Required extends boolean> = Kind extends "many" ? "many" : Required extends true ? "one" : "nullable";
-/** Rows mode after a filter of a query whose row a required relation guarantees: `one` becomes `nullable`, or `optional` for a query of values; other modes stay. */
-type FilteredRows<Rows extends ResultRows, Value extends boolean> = Rows extends "one" ? Value extends true ? "optional" : "nullable" : Rows;
+/** Rows mode after 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. */
@@ -650,434 +807,119 @@ 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;
-/** Expressions, nested queries, and literals selected under the keys of the result fields; a record has no symbol keys. */
-interface Selection {
-  readonly [key: string]: TypedExpression | NestedQuery | Literal<unknown>;
-  readonly [key: symbol]: never;
-}
-/** Query whose rows a selection nests as the value of a field: a query of any state and kind, such as a query of a relation. */
-type NestedQuery = QueryOf<SelectQueryState>;
-/** Record of the values of the expressions, of the nested rows, and of the literals of a selection. */
-type SelectionResult<S extends Selection> = { [K in keyof S]: FieldValue<S[K]>; };
-/** Value of a selected field: of an expression, of the nested rows of a query as the result of executing it, or of a literal, for each member of a union of them. */
-type FieldValue<V> = V extends NestedQuery ? QueryResult<V["types"]> : V extends Literal<infer T> ? T : ExpressionValue<V>;
-/** Relations whose records the nested queries of a selection select. */
-type SelectionUses<S extends Selection> = S[keyof S] extends (infer V) ? V extends NestedQuery ? V["types"]["uses"] : never : never;
-/** Value of a selected expression. */
-type ExpressionValue<E> = E extends AnyExpression<infer T> ? T : never;
-/** Values that the type of an expression encodes, such as in place of its value. */
-type ExpressionInput<E> = E extends AnyExpression<unknown, infer I> ? I : never;
-declare const helperFields: unique symbol;
-/** Marker of the input fields of a helper, carrying the keys selected by its callback. */
-interface HelperFields<Keys extends PropertyKey = PropertyKey> {
-  readonly [helperFields]: Keys;
-}
-/** Records with `Fields` added or replaced, for each branch of either record type; `any` stays `any`. */
-type MergeSelection<Previous, Fields> = Previous extends unknown ? Fields extends unknown ? MergeFields<RecordFields<Previous>, RecordFields<Fields>> & (IsAny<Previous> extends true ? Previous : unknown) : never : never;
-/** Fields with numeric keys represented as the string keys used in result records. */
-type RecordFields<Fields> = Fields extends unknown ? [Extract<keyof Fields, number>] extends [never] ? Fields : { [K in keyof Fields as K extends number ? `${K}` : K]: Fields[K]; } : never;
-/** Merge of normalized fields, retaining the previous value when an optional replacement is absent. */
-type MergeFields<Previous, Fields> = Simplify<{ [K in keyof Previous as K extends keyof Fields ? ({} extends Pick<Fields, K> ? K : never) : K]: K extends typeof helperFields // A branch selecting extra keys must not be reduced to one selecting fewer fields or none.
- ? Previous[K] | keyof Fields : K extends keyof Fields // A decoder can return undefined, so it cannot be excluded as merely an absent property.
- ? Previous[K] | Fields[K] : Previous[K]; } & { [K in keyof Fields as K extends keyof Previous ? ({} extends Pick<Fields, K> ? never : K) : K]: Fields[K]; }>;
-/** State of a query of `$select` in types: one record `R`, whose nested queries select records of relations `U`. */
-interface RecordQueryState$1<R = unknown, U extends UsedRelation = UsedRelation> extends QueryState {
-  readonly result: R;
-  readonly rows: "one";
-  readonly value: false;
-  readonly uses: U;
+/** Type of the value of a query of `exists`. */
+interface ExistsValueType extends QueryValueType {
+  readonly input: boolean;
+  readonly operators: EqualityOperators;
 }
-/** State of the query of `$select` of `Sel`: the record of the values of its expressions and of its literals and the results of its queries. */
-type SelectionState<Sel extends Selection> = RecordQueryState$1<MergeSelection<EmptyRecord, SelectionResult<Sel>>, SelectionUses<Sel>>;
+declare const conditionValues: unique symbol;
+/** Predicate accepted by `where`, `and`, `or`, and `not`; SQL treats a `NULL` predicate as not satisfied. */
+type Predicate = AnyExpression<boolean | null>;
 /**
- * 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.
+ * Condition combining expressions with objects of column values, such as `or({ published: true }, form.id.in(ids))`.
  *
- * 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.
+ * `where` matches the objects against the columns of its query, so a condition is accepted only where `V` matches the table.
  */
-declare class RecordQuery<out S extends RecordQueryState$1, out Kind extends SelectQueryKind = "unbound"> {
-  readonly node: RecordQueryNode;
-  readonly types: S;
-  /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
-  readonly db: QueryDb<Kind>;
-  /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
-  readonly then: QueryThen<S, Kind>;
-  constructor(node: RecordQueryNode, db?: AnyDb);
-  /**
-   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
-   *
-   * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
-   */
-  toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
-  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-  [operandNode](): never;
+interface Condition<V> {
+  readonly [conditionValues]?: V;
 }
-/** Query of `$select` of any state and kind. */
-type AnyRecordQuery = RecordQuery<any, SelectQueryKind>;
-declare const schemaBrand: unique symbol;
-/** Key of the relation definitions of a schema, which composition reads. */
-declare const schemaRelations: unique symbol;
-/** Tables by their keys; a key must not start with `$`, which is reserved for schema and `Db` members. */
-type Tables = Record<string, AnyTable>;
 /**
- * Immutable collection of tables and their relations with query entry points.
+ * Operand of `and`, `or`, and `not`: a predicate, a query of one Boolean value, such as of `exists`, a condition, or an object of column values.
  *
- * A schema is not bound to a database, so queries built from it can be defined at module level.
- * A `Db` can execute such a query if its schema contains the tables and the selected relations of the query and every bound nested query belongs to that `Db`.
+ * Column values `V` are never inferred from an object, so that object keys are checked against the table instead of determining `V`.
  */
-type Schema<T extends Tables, R extends SchemaRelations = EmptyRecord> = SchemaEntries<T, R> & SchemaMembers<T, R>;
-/** Query entry points; each access starts a query over a new table occurrence. */
-type SchemaEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: SelectQuery<InitialQueryState<T[K], TableContext<R, K>>>; };
-/** Members of a schema that composition reads: its tables and the relations of its tables. */
-interface SchemaContents<T extends Tables, R extends SchemaRelations> {
-  readonly [schemaBrand]: true;
-  /** Tables of the schema by their keys. */
-  readonly $tables: T;
-  /** Relation definitions by table key and relation name. */
-  readonly [schemaRelations]: R;
-}
-interface SchemaMembers<T extends Tables, R extends SchemaRelations> extends SchemaContents<T, R> {
-  /**
-   * Creates a schema of the same tables with the relations of `relations` added, declared with `many` and `one` by their names under the keys of their tables.
-   *
-   * A relation refers to a table of the schema by columns of SQL types that `=` compares; a relation that the schema already has is rejected.
-   */
-  $relations<S extends AnySchema, D extends RelationDeclarations<S["$tables"]>>(this: S, relations: D & CheckDeclarations<S["$tables"], D>): Schema<S["$tables"], MergeRelations<S[typeof schemaRelations] & DeclaredRelations<S["$tables"], D>>>;
-  /**
-   * Starts an unbound query of one record whose fields are the values of the expressions and of the literals and the results of the queries of `selection`, selected in one statement.
-   *
-   * The value of the field of a query is the result it gives when executed, such as an array of records or one value.
-   */
-  $select<Sel extends Selection>(selection: Sel): RecordQuery<SelectionState<Sel>>;
-}
-/** Schema of any tables and relations. */
-type AnySchema = SchemaContents<Tables, SchemaRelations>;
-/** Part of a schema definition: an object of tables by their keys, or a schema whose tables and relations it includes. */
-type SchemaPart = Tables | AnySchema;
+type ConditionOperand<V, T extends boolean | null = boolean | null> = AnyExpression<T> | ScalarQuery<T> | Condition<V> | NoInfer<V>;
 /**
- * Tables of the parts of a schema definition by their keys.
+ * Result of `and`, `or`, and `not`: a condition checked against the table inside `where`, a Boolean expression without a table.
+ */
+type CombinedCondition<V, T extends boolean | null = boolean | null> = [V] extends [never] ? Expression<BooleanResult<T>> : Condition<V>;
+/** Combines predicates with `AND`; no operands yield `TRUE`. */
+declare function and<V = never, T extends boolean | null = [V] extends [never] ? boolean : boolean | null>(...operands: ConditionOperand<V, T>[]): CombinedCondition<V, T>;
+/** Combines predicates with `OR`; no operands yield `FALSE`. */
+declare function or<V = never, T extends boolean | null = [V] extends [never] ? boolean : boolean | null>(...operands: ConditionOperand<V, T>[]): CombinedCondition<V, T>;
+/** Negates a predicate. */
+declare function not<V = never, T extends boolean | null = [V] extends [never] ? boolean : boolean | null>(operand: ConditionOperand<V, T>): CombinedCondition<V, T>;
+/**
+ * Filter by column values, each matched by the `eq` operator of its column; `null` matches `IS NULL`.
  *
- * A part typed as a union gives a union of tables, and parts of an array of unknown length give no tables, since any of them may be missing.
+ * A column without an `eq` operator of one operand accepts only `null` in this filter, when its input type includes `null`.
  */
-type SchemaTables<P extends readonly SchemaPart[]> = ComposeParts<P>["tables"] extends (infer T extends Tables) ? { [K in keyof T]: T[K]; } : never;
-/** Relations of the parts of a schema definition by table key and relation name, read as `SchemaTables` reads the tables. */
-type SchemaPartRelations<P extends readonly SchemaPart[]> = ComposeParts<P>["relations"] extends (infer R extends SchemaRelations) ? MergeRelations<R> : never;
-/** Tables and relations of the parts of a schema definition, intersected. */
-interface PartContents {
-  readonly tables: Tables;
-  readonly relations: SchemaRelations;
-}
-type ComposeParts<P extends readonly SchemaPart[], Composed extends PartContents = {
-  tables: EmptyRecord;
-  relations: EmptyRecord;
-}> = P extends readonly [infer First extends SchemaPart, ...infer Rest extends readonly SchemaPart[]] ? ComposeParts<Rest, Composed & ReadPart<First>> : P extends readonly [...infer Rest extends readonly SchemaPart[], infer Last extends SchemaPart] ? ComposeParts<Rest, Composed & ReadPart<Last>> : Composed;
-type ReadPart<P extends SchemaPart> = P extends SchemaContents<infer T, any> ? {
-  tables: T;
-  relations: P[typeof schemaRelations];
-} : {
-  tables: P;
-  relations: EmptyRecord;
-};
+type WhereValues<T extends AnyTable> = { [K in keyof T["columns"]]?: EqValue<T, K> | (null extends ColumnValues<T>[K] ? null : never); };
+/** Operand of the `eq` operator of column `K` of table `T` in an object passed to `where`, such as an expression. */
+type EqValue<T extends AnyTable, K extends keyof T["columns"]> = IsAny<ColumnOperators<T, K>> extends true ? ColumnValues<T>[K] : ColumnOperators<T, K> extends {
+  readonly eq: EqualityOperator<ComparisonSignature>;
+} ? Operand<TypeOutput<T["columns"][K]["type"]>, TypeInput<T["columns"][K]["type"]>> : EqOperand<ColumnRefs<T>[K]>;
+/** Operand of the `eq` operator of an expression, if it has one taking a single operand and returning a predicate. */
+type EqOperand<E> = E extends {
+  eq: (value: infer V) => Predicate;
+} ? V : never;
+/** Filter of `where`: a Boolean expression, a query of one Boolean value, such as of `exists`, an object of column values, or their combination with `and`, `or`, and `not`. */
+type WhereCondition<T extends AnyTable> = ConditionOperand<WhereValues<T>>;
+/** Callback of `where` over table `T` with schema context `C`: it receives the columns and the queries of the relations of the table and returns a condition. */
+type WhereCallback<T extends AnyTable, C extends SchemaContext = NoRelations> = (columns: ColumnRefs<T> & RelationRefs<C>) => WhereCondition<T>;
+/** 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 schema of the tables of `parts`, keyed by their names in queries.
+ * 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.
  *
- * A part is an object of tables by their keys or another schema, whose tables and relations the new schema includes as they are, so queries built from that schema run on the new one.
- * A key of two different tables, a table under two keys, and two different definitions of a relation of a table are rejected; the same table under the same key or the same relation in several parts is one.
+ * 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 defineSchema<P extends SchemaPart[]>(...parts: P): Schema<SchemaTables<P>, SchemaPartRelations<P>>;
-declare const sourceTable: unique symbol;
-declare const sourceKey: unique symbol;
-/** Runtime mark of the declarations of `many` and `one`. */
-declare const declarationBrand: unique symbol;
-/** Kind of a relation: `many` related records, or `one` related record at most. */
-type RelationKind = "many" | "one";
-/** Relation of a table of a schema to the records of table `Target`, which has key `TargetKey` in the schema. */
-interface Relation<Kind extends RelationKind = RelationKind, Target extends AnyTable = AnyTable, TargetKey extends string = string, Required extends boolean = boolean> {
-  readonly kind: Kind;
-  readonly target: Target;
-  readonly targetKey: TargetKey;
-  /** Whether every record of the table has its related record, so that a query of a relation `one` without a filter rejects without it rather than giving `null`; `false` for a relation `many`. */
-  readonly required: Required;
-}
+type QueryWhereFilter<S extends SelectQueryState> = [S] extends [unknown] ? WhereFilter<S["table"], S["schema"]> : never;
 /**
- * Relation of a table of a schema as `$relations` defines it: the columns of its keys, compared by SQL `=` in order.
+ * 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.
  *
- * Composition includes a definition as it is, so a relation that several parts include is one definition.
+ * A union of tables gives the union of their values.
  */
-interface RelationDefinition extends Relation {
-  readonly name: string;
-  /** Key of the source table. */
-  readonly key: string;
-  readonly source: AnyTable;
-  readonly from: readonly string[];
-  readonly to: readonly string[];
-}
-/** Relation `N` of the table under key `K` of a schema, of type `R`, whose records a query selects. */
-interface UsedRelation<K extends string = string, N extends string = string, R extends Relation = Relation> {
-  readonly key: K;
-  readonly name: N;
-  readonly relation: R;
-}
-/** Relations of schema relations `R` that the queries of a `Db` of the schema may select. */
-type UsableRelation<R extends SchemaRelations> = { [K in keyof R & string]: { [N in keyof R[K] & string]: UsedRelation<K, N, R[K][N]>; }[keyof R[K] & string]; }[keyof R & string];
-/** Relations of the tables of a schema by table key and relation name. */
-type SchemaRelations = {
-  readonly [key: string]: TableRelations;
-};
-/** Relations of a table of a schema by relation name. */
-type TableRelations = {
-  readonly [name: string]: Relation;
-};
+type PrimaryKeyValues<T extends AnyTable> = T extends AnyTable ? T["keys"] extends TableKeys<infer PrimaryKey extends KeyColumns, infer _UniqueKey> ? { readonly [I in keyof PrimaryKey]: NonNullable<EqValue<T, PrimaryKey[I] & keyof T["columns"]>>; } : never : never;
+/** Columns of the primary key of table `T`, or `never` where the type of `T` tells no primary key. */
+type PrimaryKeyColumn<T extends AnyTable> = T extends AnyTable ? T["keys"] extends TableKeys<infer PrimaryKey extends KeyColumns, infer _UniqueKey> ? PrimaryKey[number] : never : never;
 /**
- * Declaration of a relation by `many` or `one`, which `$relations` of a schema defines for a table of type `Source` with key `From` of the source table.
+ * Check of columns `Columns`, of the object of `findBy` or of `onConflict`, that rejects them unless they are exactly a key of table `T`, primary or unique, as the type of `T` tells.
  *
- * `Source` and `From` only type the keys of the source table.
+ * A table of `any`, such as of `AnySelectQuery`, takes any columns, as `where` takes any values there.
  */
-interface RelationDeclaration<Kind extends RelationKind, Source extends AnyTable, Target extends AnyTable, From = unknown, Required extends boolean = boolean> {
-  readonly [declarationBrand]: true;
-  readonly kind: Kind;
-  readonly target: Target;
-  readonly from: readonly string[];
-  readonly to: readonly string[];
-  readonly required: Required;
-  readonly [sourceTable]?: (source: Source) => void;
-  readonly [sourceKey]?: From;
-}
-/** Column key of table `T` whose type has SQL `=`, which a relation can compare. */
-type EqualityKey<T extends AnyTable> = { [K in keyof T["columns"]]: HasEquality<ColumnOperators<T, K>> extends true ? K : never; }[keyof T["columns"]] & string;
-/** Key of a relation in table `T`: a column key, or a non-empty list of them for a composite key. */
-type RelationKey<T extends AnyTable> = EqualityKey<T> | readonly [EqualityKey<T>, ...EqualityKey<T>[]];
-/** Key of table `T` with as many columns as key `From`. */
-type MatchingKey<T extends AnyTable, From> = From extends string ? EqualityKey<T> : { readonly [I in keyof From]: EqualityKey<T>; };
-/** Keys of a relation: the columns `from` of the source table equal the columns `to` of the target table, in order. */
-interface RelationKeys<Target extends AnyTable, From> {
-  readonly from: From;
-  readonly to: MatchingKey<Target, From>;
-}
-/** Keys of a relation `one`, as in `RelationKeys`, and whether the relation is required. */
-interface OneRelationKeys<From, To> {
-  readonly from: From;
-  readonly to: To;
-  /** Whether every record has its related record, such as by a foreign key on columns `from` that are not nullable, so that a query of the relation without a filter rejects without it rather than giving `null`. */
-  readonly required?: boolean;
+type KeyCheck<T extends AnyTable, Columns> = [IsKey<T, Columns>] extends [true] ? unknown : IsAny<T> extends true ? unknown : NotAKey<KeyOf<T["keys"]>>;
+/** Type that the columns of `findBy` and `onConflict` are checked against when they are not exactly a key of the table, naming the keys of the table. */
+interface NotAKey<Keys> {
+  readonly "columns must be exactly one key of the table": Keys;
 }
-/** Members of the keys `K` of a relation `one` with only `required` typed, so that a call infers `K` with `required` as optional as it is, and reports a wrong key at its own member. */
-type RequiredMember<K> = { readonly [P in keyof K]: P extends "required" ? K[P] : unknown; };
-/** Whether the keys `K` of a relation `one` make it required: only where they set `required` to `true`, and `boolean` where `required` may be `true` or missing, such as `required?: true`. */
-type DeclaredRequiredOf<K> = K extends unknown ? "required" extends keyof K ? K extends {
-  readonly required: infer Required;
-} ? IsTrue<Required> : IsTrue<K["required" & keyof K] | undefined> : false : never;
-/** `true` for `true`, and `false` for other values, such as `false` and `undefined`; a union gives the union of their results. */
-type IsTrue<T> = T extends true ? true : false;
-/** Declarations of `$relations` of a schema of tables `T`: relations by name, for tables by their keys. */
-type RelationDeclarations<T extends Tables> = { readonly [K in keyof T]?: {
-  readonly [name: string]: RelationDeclaration<RelationKind, T[K], T[keyof T]>;
-}; };
+/** 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[];
 /**
- * Declarations `D` of `$relations` checked by the names they use: relations of the tables of `T` under their keys, and no other keys.
+ * 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.
  *
- * Declarations under the names of `D` get their source table from this type even where the index signature of `RelationDeclarations` gives way to a member of `Object`, such as for a relation named `toString`.
- * A relation name must not be a column key of its table or start with `$`, since the references that the callback of `select` gets have both.
+ * 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 CheckDeclarations<T extends Tables, D> = { readonly [K in keyof D]: [TableKey<T, K>] extends [never] ? never : undefined extends D[K] ? D[K] : { readonly [N in keyof D[K]]: `${N & (string | number)}` extends ReservedName<T[TableKey<T, K>]> ? never : RelationDeclaration<RelationKind, T[TableKey<T, K>], T[keyof T], RelationKey<T[TableKey<T, K>]>>; }; };
-/** Names that a relation of table `T` cannot have: the keys of its columns, and names starting with `$`. */
-type ReservedName<T extends AnyTable> = `${keyof T["columns"] & (string | number)}` | `$${string}`;
-/** Key of tables `T` written as key `K`, such as `1` for `"1"`, as object keys are strings at runtime. */
-type TableKey<T extends Tables, K> = { [P in keyof T]: `${P & (string | number)}` extends `${K & (string | number)}` ? P : never; }[keyof T];
-/** Relations that declarations `D` of a schema of tables `T` define, by table key and relation name, as strings like the keys of objects. */
-type DeclaredRelations<T extends Tables, D> = { [K in keyof D as K extends number ? `${K}` : K]: { [N in keyof D[K] as N extends number ? `${N}` : N]: D[K][N] extends RelationDeclaration<infer Kind, never, infer Target, unknown, infer Required> ? Relation<Kind, Target, KeyOfTable<T, Target>, Required> : never; }; };
-/** Column key of relation key `K`: the key itself, or a column of a composite key. */
-type RelationColumn<K> = K extends readonly unknown[] ? K[number] : K;
-/** Check of key `To` of a relation `one` that rejects it when its columns include no key of table `Target`, as far as the types tell. */
-type TargetKeyCheck<Target extends AnyTable, To> = [ContainsKey<Target, RelationColumn<To>>] extends [false] ? {
-  readonly to: MissingKey<KeyOf<Target["keys"]>>;
-} : unknown;
-/** Type that a key `to` of a relation `one` without a key of its target is checked against, naming the keys of the target. */
-interface MissingKey<Keys> {
-  readonly "columns to must include a key of the target": Keys;
-}
-/** Key of table `Target` among tables `T`, as a string like the keys of objects. */
-type KeyOfTable<T extends Tables, Target> = { [K in keyof T]: [T[K]] extends [Target] ? [Target] extends [T[K]] ? K extends number ? `${K}` : K & string : never : never; }[keyof T];
-/** Relations of `R` by table key, with the relations under the same key merged. */
-type MergeRelations<R> = { [K in keyof R]: { [N in keyof R[K]]: R[K][N]; }; };
-/** Relations of the schema that a query starts from, by table key, and the key of the table of the query there. */
-interface SchemaContext<R extends SchemaRelations = SchemaRelations, K extends string = string> {
-  readonly relations: R;
-  readonly key: K;
-}
-/** Schema context of a query whose table has no relations, such as one of `from(table)`. */
-type NoRelations = SchemaContext<EmptyRecord, string>;
-/** Schema context of the queries of the table under key `K` of a schema of relations `R`, whose keys are strings, as object keys are at runtime. */
-type TableContext<R extends SchemaRelations, K> = K extends keyof R ? [keyof R[K]] extends [never] ? NoRelations : SchemaContext<R, K & string> : K extends number ? TableContext<R, `${K}`> : NoRelations;
+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>;
 /**
- * Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+ * 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 composite key lists its columns in arrays of the same length.
+ * It reads `S` only in its branch, as `QueryWhereFilter` does.
  */
-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>;
+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;
 /**
- * Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+ * What a query with a row lock does with a row that another transaction has locked, instead of waiting for it:
  *
- * 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.
+ * - `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 function one<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>, const To extends MatchingKey<Target, From>, const Keys extends object = EmptyRecord>(target: Target, keys: OneRelationKeys<From, To> & RequiredMember<Keys> & TargetKeyCheck<Target, To>): RelationDeclaration<"one", Source, Target, From, NoInfer<DeclaredRequiredOf<Keys>>>;
-/** Type of a count: a `bigint` of PostgreSQL decoded as a number, rejecting a count that a number cannot hold exactly. */
-declare const countType: BaseType<number, number, MergeOperators<NoOperators, {
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
-  lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-  gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
-}>, undefined>;
-/** Type of the value of a query of a count. */
-interface CountValueType extends QueryValueType {
-  readonly input: TypeInput<typeof countType>;
-  readonly operators: TypeOperators<typeof countType>;
-}
-/** 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 queries receive beside the columns.
- *
- * A relation name is never a column key of its table.
- * A context whose table key is not known, such as one of a query of any schema, has no relations.
- */
-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;
-}
-/** Type of the value of a query of `exists`. */
-interface ExistsValueType extends QueryValueType {
-  readonly input: boolean;
-  readonly operators: EqualityOperators;
-}
-declare const conditionValues: unique symbol;
-/** Predicate accepted by `where`, `and`, `or`, and `not`; SQL treats a `NULL` predicate as not satisfied. */
-type Predicate = AnyExpression<boolean | null>;
-/**
- * Condition combining expressions with objects of column values, such as `or({ published: true }, form.id.in(ids))`.
- *
- * `where` matches the objects against the columns of its query, so a condition is accepted only where `V` matches the table.
- */
-interface Condition<V> {
-  readonly [conditionValues]?: V;
-}
-/**
- * Operand of `and`, `or`, and `not`: a predicate, a query of one Boolean value, such as of `exists`, a condition, or an object of column values.
- *
- * Column values `V` are never inferred from an object, so that object keys are checked against the table instead of determining `V`.
- */
-type ConditionOperand<V, T extends boolean | null = boolean | null> = AnyExpression<T> | ScalarQuery<T> | Condition<V> | NoInfer<V>;
-/**
- * Result of `and`, `or`, and `not`: a condition checked against the table inside `where`, a Boolean expression without a table.
- */
-type CombinedCondition<V, T extends boolean | null = boolean | null> = [V] extends [never] ? Expression<BooleanResult<T>> : Condition<V>;
-/** Combines predicates with `AND`; no operands yield `TRUE`. */
-declare function and<V = never, T extends boolean | null = [V] extends [never] ? boolean : boolean | null>(...operands: ConditionOperand<V, T>[]): CombinedCondition<V, T>;
-/** Combines predicates with `OR`; no operands yield `FALSE`. */
-declare function or<V = never, T extends boolean | null = [V] extends [never] ? boolean : boolean | null>(...operands: ConditionOperand<V, T>[]): CombinedCondition<V, T>;
-/** Negates a predicate. */
-declare function not<V = never, T extends boolean | null = [V] extends [never] ? boolean : boolean | null>(operand: ConditionOperand<V, T>): CombinedCondition<V, T>;
-/**
- * Filter by column values, each matched by the `eq` operator of its column; `null` matches `IS NULL`.
- *
- * A column without an `eq` operator of one operand accepts only `null` in this filter, when its input type includes `null`.
- */
-type WhereValues<T extends AnyTable> = { [K in keyof T["columns"]]?: EqValue<T, K> | (null extends ColumnValues<T>[K] ? null : never); };
-/** Operand of the `eq` operator of column `K` of table `T` in an object passed to `where`, such as an expression. */
-type EqValue<T extends AnyTable, K extends keyof T["columns"]> = IsAny<ColumnOperators<T, K>> extends true ? ColumnValues<T>[K] : ColumnOperators<T, K> extends {
-  readonly eq: EqualityOperator<ComparisonSignature>;
-} ? Operand<TypeOutput<T["columns"][K]["type"]>, TypeInput<T["columns"][K]["type"]>> : EqOperand<ColumnRefs<T>[K]>;
-/** Operand of the `eq` operator of an expression, if it has one taking a single operand and returning a predicate. */
-type EqOperand<E> = E extends {
-  eq: (value: infer V) => Predicate;
-} ? V : never;
-/** Filter of `where`: a Boolean expression, a query of one Boolean value, such as of `exists`, an object of column values, or their combination with `and`, `or`, and `not`. */
-type WhereCondition<T extends AnyTable> = ConditionOperand<WhereValues<T>>;
-/** Callback of `where` over table `T` with schema context `C`: it receives the columns and the queries of the relations of the table and returns a condition. */
-type WhereCallback<T extends AnyTable, C extends SchemaContext = NoRelations> = (columns: ColumnRefs<T> & RelationRefs<C>) => WhereCondition<T>;
-/** 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>;
-/**
- * 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.
- *
- * TypeScript types the body of a callback once, for every overload, and a plain `WhereFilter` leaves `S` unresolved there, so the body would widen a literal, such as of an enum column, to `string`.
- * It reads the filter only in its branch: a general alias that takes the filter as an argument resolves it on every call, which takes about 25 more instantiations.
- */
-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.
- *
- * A union of tables gives the union of their values.
- */
-type PrimaryKeyValues<T extends AnyTable> = T extends AnyTable ? T["keys"] extends TableKeys<infer PrimaryKey extends KeyColumns, infer _UniqueKey> ? { readonly [I in keyof PrimaryKey]: NonNullable<EqValue<T, PrimaryKey[I] & keyof T["columns"]>>; } : never : never;
-/**
- * Check of columns `Columns` of the object of `findBy` that rejects them unless they are exactly a key of table `T`, primary or unique, as the type of `T` tells.
- *
- * A table of `any`, such as of `AnySelectQuery`, takes any columns, as `where` takes any values there.
- */
-type KeyCheck<T extends AnyTable, Columns> = [IsKey<T, Columns>] extends [true] ? unknown : IsAny<T> extends true ? unknown : NotAKey<KeyOf<T["keys"]>>;
-/** Type that the object of `findBy` is checked against when its columns are not exactly a key of the table, naming the keys of the table. */
-interface NotAKey<Keys> {
-  readonly "columns must be exactly one key of the table": Keys;
-}
-/**
- * Direction of a sort key, optionally with the placement of `NULL`.
- *
- * Without a placement, `NULL` comes last in ascending order and first in descending order.
- */
-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 callback of `orderBy` 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` sorts by its value.
- */
-type SelectedRefs<R> = { readonly [K in keyof R & string]: AnyExpression<R[K]>; };
-/** Sort keys returned by the callback of `orderBy`: one or an array of them. */
-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;
-/**
- * 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]; } & {};
+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. */
@@ -1085,58 +927,25 @@ type FilteredState<S extends SelectQueryState> = ChangeState<S, {
   rows: FilteredStateRows<S>;
   guaranteed: false;
 }>;
-/** State `S` after a filter followed by `take`, as `find` and `findBy` change it. */
-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];
-/** 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;
+/** State `S` after a filter followed by `take`, as `find` and `findBy` change it, with the columns `K` of their key for `upsert`. */
+interface FoundState<S extends SelectQueryState, K extends string> extends SelectQueryState, FoundKey<K> {
+  readonly table: S["table"];
+  readonly schema: S["schema"];
+  readonly result: S["result"];
+  readonly rows: OneRow<FilteredStateRows<S>>;
+  readonly value: S["value"];
+  readonly valueType: S["valueType"];
+  readonly fieldTypes: S["fieldTypes"];
+  readonly uses: S["uses"];
+  readonly guaranteed: false;
+  readonly aggregate: S["aggregate"];
 }
+/** State of a query of `find` or `findBy`, or of a singleton table, which `upsert` applies to. */
+type FoundQueryState = SelectQueryState & {
+  readonly foundKey: string;
+};
 /** State of a query whose rows are records, which `select` and `clearSelect` change. */
-type RecordQueryState = SelectQueryState & {
+type RecordQueryState$1 = SelectQueryState & {
   readonly value: false;
 };
 /** State of a query whose row no relation guarantees, which a filter keeps. */
@@ -1147,16 +956,22 @@ 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];
@@ -1167,6 +982,27 @@ 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;
@@ -1198,14 +1034,42 @@ type CoalescedValue<V, F> = Exclude<V, null> | Extract<OperandValue<F>, null>;
 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 `upsert` into table `T`: a record of an insert without the columns `K` of the key, whose values `find` or `findBy` gives. */
+type UpsertValues<T extends AnyTable, K extends string> = { readonly [C in keyof T["columns"] as C extends OptionalColumnKey<T> | K ? never : C]: ColumnValue<T, C>; } & { readonly [C in Exclude<OptionalColumnKey<T>, K>]?: ColumnValue<T, C> | 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>);
+/** Argument of `update` of a conflict of an insert into table `T` with schema context `C`: the values that it sets on the existing record, or a callback that receives the columns and the queries of the relations of the existing record and the columns of the row proposed for insertion, and returns them. */
+type ConflictUpdateSet<T extends AnyTable, C extends SchemaContext = NoRelations> = UpdateValues<T> | ((columns: ColumnRefs<T> & RelationRefs<C>, excluded: 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]; } & {};
+/** 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`.
  *
@@ -1237,12 +1101,14 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   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, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, all: "*"): SelectQuery<ChangeState<S, {
+  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, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, ...keys: K[]): SelectQuery<ChangeState<S, {
+  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.
@@ -1251,13 +1117,15 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Each expression is decoded with its type, so it must have one: a column, an operator result, or a fragment of `sql(type)`, but not of `sql<T>`.
    * A nested query is unbound, such as a query of a relation, or bound to the `Db` that runs the query; its rows become the value of its field as they become the result of an executed query.
    */
-  select<S extends RecordQueryState, 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>>;
+  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"], 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, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
+  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`.
@@ -1273,15 +1141,17 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    *
    * A value is what `where` takes for its column, such as an expression, but never `null` or `undefined`.
    * Without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
+   * To insert the record of the key or update the existing one, call `upsert` right after it.
    */
-  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S>, Kind>;
+  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S, PrimaryKeyColumn<S["table"]>>, Kind>;
   /**
    * Filters the query by the values of the columns of one key of the table, primary or unique, and returns the row instead of an array, as `where` followed by `take`, but without a limit.
    *
    * A value is what `where` takes for its column, such as an expression, but never `null` or `undefined`.
    * Without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
+   * To insert the record of the key or update the existing one, call `upsert` right after it.
    */
-  findBy<S extends SelectQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, values: { readonly [C in K]: NonNullable<EqValue<S["table"], C>>; } & KeyCheck<S["table"], K>): SelectQuery<FoundState<S>, Kind>;
+  findBy<S extends SelectQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, values: { readonly [C in K]: NonNullable<EqValue<S["table"], C>>; } & KeyCheck<S["table"], K>): SelectQuery<FoundState<S, K>, Kind>;
   /**
    * Replaces the selected fields with a column, limits the query to one row, and returns the value of the column instead of a record.
    *
@@ -1305,8 +1175,8 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * A `NULL` value is `null`.
    */
   get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<ChangeState<S, {
-    result: OperandValue<E>;
-    valueType: OperandValueType<E>;
+    result: S["aggregate"] extends Grouped ? GroupOperandValue<E> : OperandValue<E>;
+    valueType: SelectedOperandType<E>;
     rows: OneValueRows<S["rows"]>;
     value: true;
     uses: S["uses"] | OperandUses<E>;
@@ -1330,8 +1200,8 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * 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 TypedOperand>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): SelectQuery<ChangeState<S, {
-    result: OperandValue<E>;
-    valueType: OperandValueType<E>;
+    result: S["aggregate"] extends Grouped ? GroupOperandValue<E> : OperandValue<E>;
+    valueType: SelectedOperandType<E>;
     rows: ValueRows<S["rows"]>;
     value: true;
     uses: S["uses"] | OperandUses<E>;
@@ -1339,7 +1209,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /**
    * 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. */
@@ -1417,7 +1287,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /**
    * 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>;
   /**
@@ -1428,6 +1298,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)`.
@@ -1435,6 +1308,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.
    *
@@ -1442,7 +1345,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It returns an expression or a query of one value, such as of an aggregate of related records, sorted in ascending order, `asc`, `desc`, or `orderBy` of one, or an array of them.
    * A selected field sorts by the value of the field, also when it changes from row to row, such as `random()`; a field of nested rows cannot be sorted by.
    */
-  orderBy<Q extends QueryOf<RecordQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, selected: SelectedRefs<Q["types"]["result"]>) => OrderTerms): Q;
+  orderBy<Q extends QueryOf<RecordQueryState$1>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, selected: SelectedRefs<Q["types"]["result"]>) => OrderTerms): Q;
   /**
    * Sorts the values of a query made by `get` or `pluck` by the sort keys returned by `callback`, after the sort keys of earlier calls.
    *
@@ -1450,53 +1353,126 @@ 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;
-  /** 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";
-    guaranteed: false;
-  }>, Kind>;
   /**
-   * Makes a query of one record, such as one of `take`, resolve to `null` without a row.
+   * 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.
    *
-   * 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.
+   * 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.
    */
-  nullable<S extends OneRecordQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
-    rows: "nullable";
-    guaranteed: false;
-  }>, Kind>;
-  /** Makes a query of one row, such as one of `optional` or `nullable`, reject without a row. */
-  required<S extends OneRowQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
-    rows: "one";
-    guaranteed: false;
-  }>, Kind>;
+  distinct<Q extends QueryOf<ManyRowsQueryState>>(this: Q): Q;
   /**
-   * 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`.
+   * 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.
    *
-   * 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`, 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")`.
+   * `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.
    */
-  insert<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: InsertValues<S["table"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], "one">, Kind>;
+  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;
   /**
-   * Inserts records into the table of a query without clauses, such as a table of a `Db`, in one statement, and resolves to the number of the inserted rows.
+   * 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";
+    guaranteed: false;
+  }>, Kind>;
+  /**
+   * 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, 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";
+    guaranteed: false;
+  }>, Kind>;
+  /** Makes a query of one row, such as one of `optional` or `nullable`, reject without a row. */
+  required<S extends OneRowQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
+    rows: "one";
+    guaranteed: false;
+  }>, Kind>;
+  /**
+   * 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`, 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")`.
+   * To handle a conflict of the record with an existing one on a key, call `onConflict` right after `insert`.
+   */
+  insert<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: InsertValues<S["table"]>): MutationQuery<InitialInsertState<S["table"], S["schema"], "one">, Kind>;
+  /**
+   * Inserts records into the table of a query without clauses, such as a table of a `Db`, in one statement, and resolves to the number of the inserted rows.
    *
    * A record takes the values that `insert` takes, and a column that a record omits gets its default.
    * 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.
+   * To handle a conflict of a record with an existing one on a key, call `onConflict` right after `insertMany`.
+   * A singleton table, which holds one row, takes `insert` or `upsert` instead.
+   */
+  insertMany<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, records: readonly InsertValues<S["table"]>[] & InsertManyCheck<S["table"]>): MutationQuery<InitialInsertState<S["table"], S["schema"], "many">, Kind>;
+  /**
+   * Inserts the record of the key of `find` or `findBy` with `values`, or updates `values` of the existing record of the key, in one statement, and resolves to the number of the inserted or updated rows, `1`.
+   *
+   * `values` takes what `insert` takes, apart from the columns of the key, and at least one value other than `undefined`; a column omitted or given as `undefined` gets its default when the record is inserted and keeps its value when the record is updated.
+   * Call it right after `find` or `findBy` of a query of a table without other clauses, such as filters, or on a query of a singleton table without clauses, such as `db.settings.upsert(values)`, to insert or update its row.
+   * Select the fields that it returns after it, such as `upsert(values).get("id")`.
+   * To update the existing record with other values than the inserted ones, such as to increment a counter, call `onConflict` after `insert` instead.
    */
-  insertMany<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, records: readonly InsertValues<S["table"]>[]): MutationQuery<InitialMutationState<S["table"], S["schema"], "many">, Kind>;
+  upsert<S extends FoundQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: UpsertValues<S["table"], S["foundKey"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], "one">, 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.
+   * A query without a filter must call `all` to update every row, unless it is a query of a singleton table, which updates its 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>;
@@ -1506,7 +1482,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * `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.
+   * A query without a filter must call `all` to update every row, unless it is a query of a singleton table, which updates its 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"], S["schema"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
@@ -1514,12 +1490,32 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Deletes the rows that the filters of the query choose, and resolves to the number of the deleted rows.
    *
    * 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 delete every row.
+   * A query without a filter must call `all` to delete every row, unless it is a query of a singleton table, which deletes its row.
    * Select the fields that it returns after it, such as `delete().pluck("id")`.
    */
   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`.
    *
@@ -1544,7 +1540,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It rejects a query of records, which `ValuesQuery` rejects in types.
    */
   [valuesQueryNode](): NestedQueryNode;
-  /** Creates a query of the same kind and `Db` with the node changes applied. */
+  /** Creates a query of the same kind and `Db` with the node changes applied, dropping the key of `find` and `findBy` unless the changes give it. */
   private derive;
   /**
    * Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
@@ -1552,20 +1548,40 @@ 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 the relations and returns an expression or a query of one value; `delimiter` is the delimiter of `stringAgg`. */
   private aggregateBy;
   /** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
   private addFilter;
-  /** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
+  /** 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 the values of the columns of a key, returning one row like `take`.
+   *
+   * On a query of a table without clauses, it keeps `values` as the key that `upsert` inserts.
+   */
   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;
+}
+/** Check of the records of `insertMany` into table `T` that rejects them for a singleton table, which holds one row. */
+type InsertManyCheck<T extends AnyTable> = T["singleton"] extends true ? SingletonInsertMany : unknown;
+/** Type that the records of `insertMany` into a singleton table are checked against, naming the reason. */
+interface SingletonInsertMany {
+  readonly "insertMany cannot insert into a singleton table, which holds one row; use insert or upsert": never;
 }
 /** 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">;
@@ -1576,7 +1592,215 @@ type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
 /** Table of a definition such as `defineExpression`: the table itself or a query over it with schema context `C`, such as `schema.form`. */
 type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
 /** Starts a query over a new occurrence of the table. */
-declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T>>;
+declare function from<T extends Table<string, ColumnShape, AnyTableKeys, false>>(table: T): SelectQuery<InitialQueryState<T>>;
+/** Starts a query of the one row of a singleton table over a new occurrence of the table. */
+declare function from<T extends Table<string, ColumnShape, AnyTableKeys, true>>(table: T): SelectQuery<SingletonQueryState<T>>;
+/** Starts a query over a new occurrence of a table whose type does not tell whether it is a singleton table, of all its rows or of its one row. */
+declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T> | SingletonQueryState<T>>;
+/** 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 queries receive beside the columns.
+ *
+ * A relation name is never a column key of its table.
+ * A context whose table key is not known, such as one of a query of any schema, has no relations.
+ */
+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;
+}
+/**
+ * Direction of a sort key, optionally with the placement of `NULL`.
+ *
+ * Without a placement, `NULL` comes last in ascending order and first in descending order.
+ */
+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. */
@@ -1629,7 +1853,115 @@ declare function caseWhen<Output, Input, O extends OperatorDefinitions>(type: Ty
  */
 declare function caseWhen<Output, Input, O extends OperatorDefinitions, const B extends readonly CaseBranch<Output, Input>[], const E extends CaseValue<Output, Input>>(type: Type<Output, Input, O, any>, branches: B, otherwise: E): Expression<CaseResult<Output, B[number][1] | E>, O, Input>;
 /**
- * State in types of a query that inserts, updates, or deletes rows: its table and the relations of its schema, the rows mode of the rows it changes, and its result, which is their number until a selection returns their fields.
+ * 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.
  */
@@ -1638,7 +1970,7 @@ interface MutationQueryState extends QueryState {
   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. */
+  /** 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`. */
@@ -1652,6 +1984,16 @@ interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows
   readonly value: true;
   readonly uses: U;
 }
+/** State of an insert of `insert` or `insertMany` of table `T` with schema context `C` in rows mode `Rows`, before any other method. */
+interface InitialInsertState<T extends AnyTable, C extends SchemaContext, Rows extends ResultRows> extends InitialMutationState<T, C, Rows> {
+  readonly insert: true;
+}
+/** State of an insert that no method has changed since `insert` or `insertMany`, which `onConflict` applies to. */
+interface InsertMutationState extends MutationQueryState {
+  readonly insert: true;
+}
+/** Rows mode of the rows that an insert of rows mode `Rows` changes when it skips the rows that conflict: a missing row of an insert of one record. */
+type SkippedRows<Rows extends ResultRows> = Rows extends "one" ? "optional" : Rows;
 /** 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. */
@@ -1660,10 +2002,38 @@ type RecordMutationState = MutationQueryState & ({
 } | {
   readonly value: false;
 });
-/** State of a mutation of one row, which `get` applies to. */
-type OneRowMutationState = MutationQueryState & {
+/** 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. */
@@ -1692,7 +2062,7 @@ type OperandState<S extends MutationQueryState, E extends TypedOperand, Rows ext
 /**
  * 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.
+ * 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.
  */
@@ -1734,170 +2104,569 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
    */
   get<S extends OneRowMutationState, Kind extends SelectQueryKind, E extends TypedOperand>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): MutationQuery<OperandState<S, E, OneValueRows<S["changed"]>>, Kind>;
   /** Returns the value of a column of each changed row instead of the number of the rows, keeping whether the query returns an array or one value. */
-  pluck<S extends MutationQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], ValueRows<S["changed"]>>, Kind>;
+  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 MutationQueryState, Kind extends SelectQueryKind, E extends TypedOperand>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): MutationQuery<OperandState<S, E, ValueRows<S["changed"]>>, Kind>;
+  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>;
   /**
-   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
+   * 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.
    *
-   * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
+   * `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.
    */
-  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;
+  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;
+  /**
+   * Chooses the key, primary or unique, of `columns` on which a row of the insert may conflict with an existing record; without columns, `doNothing` skips a row that conflicts on any key, and `merge` and `update` update the row of a singleton table.
+   *
+   * Call it right after `insert` or `insertMany`, choose the action on its result, such as `doNothing()`, and select the fields that the mutation returns after the action.
+   */
+  onConflict<S extends InsertMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string = never>(this: MutationQuery<S, Kind>, ...columns: (K & KeyCheck<S["table"], K>)[]): ConflictTarget<S, Kind, K>;
+  /**
+   * 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>;
+/**
+ * Conflict target of an insert of state `S` on the key of columns `K`, or without columns for `never`, with methods that choose the action and return the mutation: without columns, `doNothing` takes any key, and `merge` and `update` the row of a singleton table.
+ *
+ * It is no query: awaiting it is a type error and rejects, so that an insert without an action does not resolve without running.
+ */
+declare class ConflictTarget<out S extends InsertMutationState, out Kind extends SelectQueryKind = "unbound", out K extends string = string> {
+  /** Insert whose rows conflict. */
+  readonly insert: MutationQuery<S, Kind>;
+  /** Columns of the key that the rows conflict on, in its order, or none, as `onConflict` without columns gives them. */
+  readonly target: readonly K[];
+  constructor(
+  /** Insert whose rows conflict. */
+  insert: MutationQuery<S, Kind>,
+  /** Columns of the key that the rows conflict on, in its order, or none, as `onConflict` without columns gives them. */
+  target: readonly K[]);
+  /**
+   * Skips each row that conflicts, as `ON CONFLICT DO NOTHING`, and returns the mutation.
+   *
+   * After `insert`, the mutation resolves to `0` when the row conflicts, and the fields selected after it to `undefined`.
+   * After `insertMany`, it resolves to the number of the inserted rows, and the fields selected after it are those of the inserted rows.
+   */
+  doNothing<S extends InsertMutationState, Kind extends SelectQueryKind>(this: ConflictTarget<S, Kind>): MutationQuery<ChangeMutationState<S, {
+    changed: SkippedRows<S["changed"]>;
+  }>, Kind>;
+  /**
+   * Updates the existing record of each row that conflicts with the values of `columns` of the row, as `DO UPDATE SET column = EXCLUDED.column`, or with every column that the insert gives, apart from the key, without columns, and returns the mutation of the inserted and the updated rows.
+   *
+   * Every record must give each column that it sets.
+   * After `onConflict()` without columns, it updates the row of a singleton table.
+   */
+  merge<S extends InsertMutationState, Kind extends SelectQueryKind, K extends string, C extends Exclude<keyof S["table"]["columns"] & string, K>>(this: ConflictTarget<S, Kind, K> & ConflictKeyCheck<S, K>, ...columns: C[]): MutationQuery<ChangeMutationState<S, {
+    changed: S["changed"];
+  }>, Kind>;
+  /**
+   * Updates the existing record of each row that conflicts with the values that `callback` returns, as `DO UPDATE SET`, and returns the mutation of the inserted and the updated rows.
+   *
+   * `callback` receives the columns and the queries of the relations of the existing record, and the columns of the row proposed for insertion, `excluded`, such as to add its value to the existing one.
+   * After `onConflict()` without columns, it updates the row of a singleton table.
+   */
+  update<S extends InsertMutationState, Kind extends SelectQueryKind, K extends string, F extends (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>, excluded: ColumnRefs<S["table"]>) => UpdateValues<S["table"]>>(this: ConflictTarget<S, Kind, K> & ConflictKeyCheck<S, K>, callback: F): MutationQuery<ChangeMutationState<S, {
+    uses: S["uses"] | OperandUses<ReturnType<F>[keyof ReturnType<F>]>;
+  }>, Kind>;
+  /**
+   * Updates the existing record of each row that conflicts with the values of `set`, as `DO UPDATE SET`, and returns the mutation of the inserted and the updated rows.
+   *
+   * `set` gives the values of the columns to update, or is a callback that returns them from the existing record and the row proposed for insertion, `excluded`.
+   * After `onConflict()` without columns, it updates the row of a singleton table.
+   */
+  update<S extends InsertMutationState, Kind extends SelectQueryKind, K extends string>(this: ConflictTarget<S, Kind, K> & ConflictKeyCheck<S, K>, set: ConflictUpdateSet<S["table"], S["schema"]>): MutationQuery<ChangeMutationState<S, {
+    changed: S["changed"];
+  }>, Kind>;
+  /** Rejects awaiting the conflict target, which needs an action, such as `doNothing()`. */
+  then(_action: ConflictActionRequired): never;
+  /** Returns the node of the insert, which `onConflict` takes only of an insert. */
+  private insertNode;
+  /** Creates the insert of the same kind and `Db` with `conflict`, changing rows `rows`. */
+  private derive;
+}
+/** Type of the parameter of `then` of a conflict target, which makes awaiting the target before an action a type error. */
+interface ConflictActionRequired {
+  readonly "onConflict needs an action, such as doNothing()": never;
+}
+/** Check of the columns `K` of a conflict target of an insert of state `S` that rejects `merge` and `update` of a conflict on any key, which PostgreSQL does not update, unless the table is a singleton table, whose row they update. */
+type ConflictKeyCheck<S extends InsertMutationState, K extends string> = [K] extends [never] ? S["table"]["singleton"] extends true ? unknown : ConflictKeyRequired : unknown;
+/** Type that a conflict target on any key is checked against by `merge` and `update`, naming the reason. */
+interface ConflictKeyRequired {
+  readonly "merge and update need the columns of a key in onConflict": never;
+}
+/** 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.
+   */
+  toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+  [operandNode](): never;
+}
+/** Query of `$select` of any state and kind. */
+type AnyRecordQuery = RecordQuery<any, SelectQueryKind>;
+declare const schemaBrand: unique symbol;
+/** Key of the relation definitions of a schema, which composition reads. */
+declare const schemaRelations: unique symbol;
+/** Tables by their keys; a key must not start with `$`, which is reserved for schema and `Db` members. */
+type Tables = Record<string, AnyTable>;
+/**
+ * Immutable collection of tables and their relations with query entry points.
+ *
+ * A schema is not bound to a database, so queries built from it can be defined at module level.
+ * A `Db` can execute such a query if its schema contains the tables and the selected relations of the query and every bound nested query belongs to that `Db`.
+ */
+type Schema<T extends Tables, R extends SchemaRelations = EmptyRecord> = SchemaEntries<T, R> & SchemaMembers<T, R>;
+/** Query entry points; each access starts a query over a new table occurrence, of the one row of a singleton table. */
+type SchemaEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: SelectQuery<TableQueryState<T[K], TableContext<R, K>>>; };
+/** Members of a schema that composition reads: its tables and the relations of its tables. */
+interface SchemaContents<T extends Tables, R extends SchemaRelations> {
+  readonly [schemaBrand]: true;
+  /** Tables of the schema by their keys. */
+  readonly $tables: T;
+  /** Relation definitions by table key and relation name. */
+  readonly [schemaRelations]: R;
+}
+interface SchemaMembers<T extends Tables, R extends SchemaRelations> extends SchemaContents<T, R> {
+  /**
+   * Creates a schema of the same tables with the relations of `relations` added, declared with `many` and `one` by their names under the keys of their tables.
+   *
+   * A relation refers to a table of the schema by columns of SQL types that `=` compares; a relation that the schema already has is rejected.
+   */
+  $relations<S extends AnySchema, D extends RelationDeclarations<S["$tables"]>>(this: S, relations: D & CheckDeclarations<S["$tables"], D>): Schema<S["$tables"], MergeRelations<S[typeof schemaRelations] & DeclaredRelations<S["$tables"], D>>>;
+  /**
+   * Starts an unbound query of one record whose fields are the values of the expressions and of the literals and the results of the queries of `selection`, selected in one statement.
+   *
+   * The value of the field of a query is the result it gives when executed, such as an array of records or one value.
+   */
+  $select<Sel extends Selection>(selection: Sel): RecordQuery<SelectionState<Sel>>;
+}
+/** Schema of any tables and relations. */
+type AnySchema = SchemaContents<Tables, SchemaRelations>;
+/** Part of a schema definition: an object of tables by their keys, or a schema whose tables and relations it includes. */
+type SchemaPart = Tables | AnySchema;
+/**
+ * Tables of the parts of a schema definition by their keys.
+ *
+ * A part typed as a union gives a union of tables, and parts of an array of unknown length give no tables, since any of them may be missing.
+ */
+type SchemaTables<P extends readonly SchemaPart[]> = ComposeParts<P>["tables"] extends (infer T extends Tables) ? { [K in keyof T]: T[K]; } : never;
+/** Relations of the parts of a schema definition by table key and relation name, read as `SchemaTables` reads the tables. */
+type SchemaPartRelations<P extends readonly SchemaPart[]> = ComposeParts<P>["relations"] extends (infer R extends SchemaRelations) ? MergeRelations<R> : never;
+/** Tables and relations of the parts of a schema definition, intersected. */
+interface PartContents {
+  readonly tables: Tables;
+  readonly relations: SchemaRelations;
+}
+type ComposeParts<P extends readonly SchemaPart[], Composed extends PartContents = {
+  tables: EmptyRecord;
+  relations: EmptyRecord;
+}> = P extends readonly [infer First extends SchemaPart, ...infer Rest extends readonly SchemaPart[]] ? ComposeParts<Rest, Composed & ReadPart<First>> : P extends readonly [...infer Rest extends readonly SchemaPart[], infer Last extends SchemaPart] ? ComposeParts<Rest, Composed & ReadPart<Last>> : Composed;
+type ReadPart<P extends SchemaPart> = P extends SchemaContents<infer T, any> ? {
+  tables: T;
+  relations: P[typeof schemaRelations];
+} : {
+  tables: P;
+  relations: EmptyRecord;
+};
+/**
+ * Defines a schema of the tables of `parts`, keyed by their names in queries.
+ *
+ * A part is an object of tables by their keys or another schema, whose tables and relations the new schema includes as they are, so queries built from that schema run on the new one.
+ * A key of two different tables, a table under two keys, and two different definitions of a relation of a table are rejected; the same table under the same key or the same relation in several parts is one.
+ */
+declare function defineSchema<P extends SchemaPart[]>(...parts: P): Schema<SchemaTables<P>, SchemaPartRelations<P>>;
+declare const sourceTable: unique symbol;
+declare const sourceKey: unique symbol;
+/** Runtime mark of the declarations of `many` and `one`. */
+declare const declarationBrand: unique symbol;
+/** Kind of a relation: `many` related records, or `one` related record at most. */
+type RelationKind = "many" | "one";
+/** Relation of a table of a schema to the records of table `Target`, which has key `TargetKey` in the schema. */
+interface Relation<Kind extends RelationKind = RelationKind, Target extends AnyTable = AnyTable, TargetKey extends string = string, Required extends boolean = boolean> {
+  readonly kind: Kind;
+  readonly target: Target;
+  readonly targetKey: TargetKey;
+  /** Whether every record of the table has its related record, so that a query of a relation `one` without a filter rejects without it rather than giving `null`; `false` for a relation `many`. */
+  readonly required: Required;
+}
+/**
+ * Relation of a table of a schema as `$relations` defines it: the columns of its keys, compared by SQL `=` in order.
+ *
+ * Composition includes a definition as it is, so a relation that several parts include is one definition.
+ */
+interface RelationDefinition extends Relation {
+  readonly name: string;
+  /** Key of the source table. */
+  readonly key: string;
+  readonly source: AnyTable;
+  readonly from: readonly string[];
+  readonly to: readonly string[];
+}
+/** Relation `N` of the table under key `K` of a schema, of type `R`, whose records a query selects. */
+interface UsedRelation<K extends string = string, N extends string = string, R extends Relation = Relation> {
+  readonly key: K;
+  readonly name: N;
+  readonly relation: R;
+}
+/** Relations of schema relations `R` that the queries of a `Db` of the schema may select. */
+type UsableRelation<R extends SchemaRelations> = { [K in keyof R & string]: { [N in keyof R[K] & string]: UsedRelation<K, N, R[K][N]>; }[keyof R[K] & string]; }[keyof R & string];
+/** Relations of the tables of a schema by table key and relation name. */
+type SchemaRelations = {
+  readonly [key: string]: TableRelations;
+};
+/** Relations of a table of a schema by relation name. */
+type TableRelations = {
+  readonly [name: string]: Relation;
+};
+/**
+ * Declaration of a relation by `many` or `one`, which `$relations` of a schema defines for a table of type `Source` with key `From` of the source table.
+ *
+ * `Source` and `From` only type the keys of the source table.
+ */
+interface RelationDeclaration<Kind extends RelationKind, Source extends AnyTable, Target extends AnyTable, From = unknown, Required extends boolean = boolean> {
+  readonly [declarationBrand]: true;
+  readonly kind: Kind;
+  readonly target: Target;
+  readonly from: readonly string[];
+  readonly to: readonly string[];
+  readonly required: Required;
+  readonly [sourceTable]?: (source: Source) => void;
+  readonly [sourceKey]?: From;
+}
+/** Column key of table `T` whose type has SQL `=`, which a relation can compare. */
+type EqualityKey<T extends AnyTable> = { [K in keyof T["columns"]]: HasEquality<ColumnOperators<T, K>> extends true ? K : never; }[keyof T["columns"]] & string;
+/** Key of a relation in table `T`: a column key, or a non-empty list of them for a composite key. */
+type RelationKey<T extends AnyTable> = EqualityKey<T> | readonly [EqualityKey<T>, ...EqualityKey<T>[]];
+/** Key of table `T` with as many columns as key `From`. */
+type MatchingKey<T extends AnyTable, From> = From extends string ? EqualityKey<T> : { readonly [I in keyof From]: EqualityKey<T>; };
+/** Keys of a relation: the columns `from` of the source table equal the columns `to` of the target table, in order. */
+interface RelationKeys<Target extends AnyTable, From> {
+  readonly from: From;
+  readonly to: MatchingKey<Target, From>;
+}
+/** Keys of a relation `one`, as in `RelationKeys`, and whether the relation is required. */
+interface OneRelationKeys<From, To> {
+  readonly from: From;
+  readonly to: To;
+  /** Whether every record has its related record, such as by a foreign key on columns `from` that are not nullable, so that a query of the relation without a filter rejects without it rather than giving `null`. */
+  readonly required?: boolean;
+}
+/** Members of the keys `K` of a relation `one` with only `required` typed, so that a call infers `K` with `required` as optional as it is, and reports a wrong key at its own member. */
+type RequiredMember<K> = { readonly [P in keyof K]: P extends "required" ? K[P] : unknown; };
+/** Whether the keys `K` of a relation `one` make it required: only where they set `required` to `true`, and `boolean` where `required` may be `true` or missing, such as `required?: true`. */
+type DeclaredRequiredOf<K> = K extends unknown ? "required" extends keyof K ? K extends {
+  readonly required: infer Required;
+} ? IsTrue<Required> : IsTrue<K["required" & keyof K] | undefined> : false : never;
+/** `true` for `true`, and `false` for other values, such as `false` and `undefined`; a union gives the union of their results. */
+type IsTrue<T> = T extends true ? true : false;
+/** Declarations of `$relations` of a schema of tables `T`: relations by name, for tables by their keys. */
+type RelationDeclarations<T extends Tables> = { readonly [K in keyof T]?: {
+  readonly [name: string]: RelationDeclaration<RelationKind, T[K], T[keyof T]>;
+}; };
+/**
+ * Declarations `D` of `$relations` checked by the names they use: relations of the tables of `T` under their keys, and no other keys.
+ *
+ * Declarations under the names of `D` get their source table from this type even where the index signature of `RelationDeclarations` gives way to a member of `Object`, such as for a relation named `toString`.
+ * A relation name must not be a column key of its table or start with `$`, since the references that the callback of `select` gets have both.
+ */
+type CheckDeclarations<T extends Tables, D> = { readonly [K in keyof D]: [TableKey<T, K>] extends [never] ? never : undefined extends D[K] ? D[K] : { readonly [N in keyof D[K]]: `${N & (string | number)}` extends ReservedName<T[TableKey<T, K>]> ? never : RelationDeclaration<RelationKind, T[TableKey<T, K>], T[keyof T], RelationKey<T[TableKey<T, K>]>>; }; };
+/** Names that a relation of table `T` cannot have: the keys of its columns, and names starting with `$`. */
+type ReservedName<T extends AnyTable> = `${keyof T["columns"] & (string | number)}` | `$${string}`;
+/** Key of tables `T` written as key `K`, such as `1` for `"1"`, as object keys are strings at runtime. */
+type TableKey<T extends Tables, K> = { [P in keyof T]: `${P & (string | number)}` extends `${K & (string | number)}` ? P : never; }[keyof T];
+/** Relations that declarations `D` of a schema of tables `T` define, by table key and relation name, as strings like the keys of objects. */
+type DeclaredRelations<T extends Tables, D> = { [K in keyof D as K extends number ? `${K}` : K]: { [N in keyof D[K] as N extends number ? `${N}` : N]: D[K][N] extends RelationDeclaration<infer Kind, never, infer Target, unknown, infer Required> ? Relation<Kind, Target, KeyOfTable<T, Target>, Required> : never; }; };
+/** Column key of relation key `K`: the key itself, or a column of a composite key. */
+type RelationColumn<K> = K extends readonly unknown[] ? K[number] : K;
+/** Check of key `To` of a relation `one` that rejects it when its columns include no key of table `Target`, as far as the types tell. */
+type TargetKeyCheck<Target extends AnyTable, To> = [ContainsKey<Target, RelationColumn<To>>] extends [false] ? {
+  readonly to: MissingKey<KeyOf<Target["keys"]>>;
+} : unknown;
+/** Type that a key `to` of a relation `one` without a key of its target is checked against, naming the keys of the target. */
+interface MissingKey<Keys> {
+  readonly "columns to must include a key of the target": Keys;
 }
-/** 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;
+/** Key of table `Target` among tables `T`, as a string like the keys of objects. */
+type KeyOfTable<T extends Tables, Target> = { [K in keyof T]: [T[K]] extends [Target] ? [Target] extends [T[K]] ? K extends number ? `${K}` : K & string : never : never; }[keyof T];
+/** Relations of `R` by table key, with the relations under the same key merged. */
+type MergeRelations<R> = { [K in keyof R]: { [N in keyof R[K]]: R[K][N]; }; };
+/** Relations of the schema that a query starts from, by table key, and the key of the table of the query there. */
+interface SchemaContext<R extends SchemaRelations = SchemaRelations, K extends string = string> {
+  readonly relations: R;
+  readonly key: K;
 }
-/** Record of the values that the types of fields `F` decode. */
-type DecodedFields<F extends FieldTypes> = { -readonly [K in keyof F]: TypeOutput<F[K]>; };
+/** Schema context of a query whose table has no relations, such as one of `from(table)`. */
+type NoRelations = SchemaContext<EmptyRecord, string>;
+/** Schema context of the queries of the table under key `K` of a schema of relations `R`, whose keys are strings, as object keys are at runtime. */
+type TableContext<R extends SchemaRelations, K> = K extends keyof R ? [keyof R[K]] extends [never] ? NoRelations : SchemaContext<R, K & string> : K extends number ? TableContext<R, `${K}`> : NoRelations;
 /**
- * State 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.
+ * Declares a relation of a table to the records of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
  *
- * Methods change only their own parts of the state.
+ * A composite key lists its columns in arrays of the same length.
  */
-interface 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;
+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>>>;
+/** 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. */
@@ -2110,10 +2879,10 @@ interface BindOptions {
  * Its table entries start queries bound to it, which execute when awaited.
  */
 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$1<unknown, UsableRelation<R>>, SelectQueryKind> | MutationQuery<DbMutationState<T[keyof T], UsableRelation<R>>, SelectQueryKind> | SqlQuery<SqlQueryState>;
+/** Bound query entry points; each access starts a query over a new table occurrence, of the one row of a singleton table. */
+type DbEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: BoundSelectQuery<TableQueryState<T[K], TableContext<R, K>>>; };
+/** 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;
@@ -2340,6 +3109,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;
 /**
@@ -2376,6 +3147,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";
@@ -2385,13 +3163,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 {
@@ -2408,6 +3198,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> {
@@ -2416,6 +3208,23 @@ interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
   readonly columns: readonly string[];
   /** Rows of `VALUES`, at least one, each with a value of every column in their order, or `undefined` for `DEFAULT`. */
   readonly values: readonly (readonly (ExpressionNode | undefined)[])[];
+  /** `ON CONFLICT` of the insert, or `undefined` for an insert that rejects a row that conflicts on a key. */
+  readonly conflict?: ConflictNode | undefined;
+}
+/** `ON CONFLICT` of an insert: a row that conflicts on `target` updates the existing row by `update`, or is skipped, as `DO NOTHING`, without it. */
+interface ConflictNode {
+  /**
+   * What a row conflicts on: the keys of the columns of a key of the table, in its order, none for any key, which only `DO NOTHING` takes, or `"singleton"` for the unique index of `(true)` of a singleton table, which holds its one row.
+   */
+  readonly target: readonly string[] | "singleton";
+  readonly update?: ConflictUpdateNode | undefined;
+}
+/** `DO UPDATE SET` of `ON CONFLICT`, whose values see the existing row as the target of the insert and the row proposed for insertion as `excluded`. */
+interface ConflictUpdateNode {
+  /** Assignments of `SET`, at least one, with unique keys. */
+  readonly set: readonly AssignmentNode[];
+  /** Occurrence of the table that stands for the row proposed for insertion, `EXCLUDED` of PostgreSQL, which the values of `set` refer to and which is in no `FROM`. */
+  readonly excluded: TableSourceNode;
 }
 /** Update statement of the rows that its filters choose. */
 interface UpdateNode<Field = ProjectionNode> extends MutationParts<Field> {
@@ -2564,89 +3373,6 @@ type MatchResult<R, V> = boolean | (V extends unknown ? { [K in keyof V]-?: K ex
  * Unlike such an object in `and`, `or`, and `not`, the expression refers to the columns it receives whichever query it is used in, and applies wherever an expression does, such as in `select`.
  */
 declare function matches<R extends object, const V extends { readonly [K in ColumnRefKey<R>]?: unknown; }>(columns: R, values: V & MatchCheck<R, V>): Expression<MatchResult<R, V>>;
-/**
- * State of the query that the callback of a helper of table `T` with schema context `C` receives: the fields of the query the helper is applied to, and all its rows.
- *
- * 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.
- *
- * `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 {
-  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>;
-}
-/** 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>;
-/**
- * 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`, or an aggregate method does not accept a helper that selects fields.
- */
-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, 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.
- */
-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>;
 /** 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>;
 /**
@@ -2683,4 +3409,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 { InitialSqlQueryState as $, EmptyRecord as $n, KeyKind as $r, Predicate as $t, AnyDb as A, SchemaPartRelations as An, RequiredRelationError as Ar, UpdateSet as At, TransactionCoordinator as B, MergeSelection as Bn, AnyType as Br, desc as Bt, orderingOperators as C, UsableRelation as Cn, Selectable as Cr, ScalarQuery as Ct, ExpressionOperators as D, AnySchema as Dn, ToColumns as Dr, from as Dt, Expression as E, one as En, TableOptions as Er, ValuesQuery as Et, DbQueryState as F, RecordQuery as Fn, Driver as Fr, OrderTerm as Ft, TestHooks as G, FilteredRows as Gn, TypeOperators as Gr, EqValue as Gt, PendingTestFixture as H, Selection as Hn, TextValue as Hr, KeyCheck as Ht, Database as I, RecordQueryState$1 as In, DriverResult as Ir, OrderTerms as It, AnyQuery as J, QueryResult as Jn, TypeTransform as Jr, WhereFilter as Jt, TestTransactionOptions as K, OneRow as Kn, TypeOptions as Kr, WhereCallback as Kt, DatabaseOptions as L, SelectionState as Ln, SqlStatement as Lr, Ordering as Lt, Db as M, Tables as Mn, ResultMode as Mr, OrderColumns as Mt, DbMutationState as N, defineSchema as Nn, ResultRows as Nr, OrderDirection as Nt, TypedExpression as O, Schema as On, defineTable as Or, ColumnValue as Ot, DbOf as P, AnyRecordQuery as Pn, Connection as Pr, OrderKey as Pt, FieldTypes as Q, literal as Qn, ColumnAttributes as Qr, ConditionOperand as Qt, TransactionOptions as R, ExpressionInput as Rn, TransactionFailure as Rr, SelectedRefs as Rt, NumberTypeOperators as S, TableRelations as Sn, KeyColumns as Sr, ResultOf as St, BaseOperators as T, many as Tn, TableKeys as Tr, TypedScalarQuery as Tt, TestFixture as U, SelectionResult as Un, Type as Ur, NotAKey as Ut, OpenedTestFixture as V, NestedQuery as Vn, BaseType as Vr, orderBy as Vt, TestHelpers as W, SelectionUses as Wn, TypeInput as Wr, PrimaryKeyValues as Wt, AnySqlQuery as X, ValueRows as Xn, AnyColumn as Xr, CombinedCondition as Xt, SelectQueryKind as Y, ResultByRows as Yn, defineType as Yr, WhereValues as Yt, DecodedFields as Z, Literal as Zn, Column as Zr, Condition as Zt, TextConversionSignature as _, RelationKind as _n, AnyTableKeys as _r, least as _t, Helper as a, GenericOperator as ai, QueryContext as an, EqualityOperator as ar, MutationQueryState as at, TextTypeOperators as b, SchemaRelations as bn, ColumnShape as br, FilteredStateRows as bt, ColumnRefKey as c, defineGenericOperator as ci, DeclaredRelations as cn, InSignature as cr, CaseValue as ct, NotAColumn as d, OneRelationKeys as dn, ComparisonSignature as dr, TypedOperand as dt, ToColumn as ei, and as en, InitialQueryState as er, SqlQuery as et, matches as f, Relation as fn, Operand as fr, TypedOperandInput as ft, PatternSignature as g, RelationKeys as gn, AnyTable as gr, greatest as gt, TRUE as h, RelationKey as hn, CompileOptions as hr, coalesce as ht, sql as i, OperatorDefinitions as ii, ColumnRefs as in, SelectQueryState as ir, MutationQuery as it, BindOptions as j, SchemaTables as jn, ResultDecodeError as jr, UpdateValues as jt, UntypedExpression as k, SchemaPart as kn, NotFoundError as kr, InsertValues as kt, MatchCheck as l, MergeRelations as ln, equalityOperators as lr, FollowingOperand as lt, FALSE as m, RelationDeclarations as mn, compare as mr, caseWhen as mt, identifier as n, MergeOperators as ni, or as nn, QueryStateOf as nr, AnyMutationQuery as nt, HelperEffect as o, GenericOperatorImplementation as oi, RelationRefs as on, EqualityOperators as or, CaseBranch as ot, defineExpression as p, RelationDeclaration as pn, OperandValue as pr, TypedOperandOperators as pt, createTestHelpers as q, OneValueRows as qn, TypeOutput as qr, WhereCondition as qt, param as r, NoOperators as ri, ExistsValueType as rn, QueryValueType as rr, InitialMutationState as rt, defineHelper as s, OperatorSignature as si, CountValueType as sn, HasEquality as sr, CaseCondition as st, SqlTemplate as t, BoundOperators as ti, not as tn, QueryState as tr, SqlQueryState as tt, MatchResult as u, NoRelations as un, BooleanResult as ur, NullSkippingResult as ut, TextLengthSignature as v, RequiredMember as vn, ColumnDefinitions as vr, AnySelectQuery as vt, AnyExpression as w, UsedRelation as wn, Table as wr, SelectQuery as wt, textOperators as x, TableContext as xn, ColumnValues as xr, OperandUses as xt, TextOperators as y, SchemaContext as yn, ColumnOperators as yr, BoundSelectQuery as yt, createDatabase as z, ExpressionValue as zn, createStatement as zr, asc as zt };
+/**
+ * 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 $, BoundOperators as $i, ResultOf as $n, ScalarQuery as $r, TypedOperandInput as $t, Db as A, ResultMode as Ai, count as An, and as Ar, DecodedFields as At, PendingTestFixture as B, TextValue as Bi, OrderKey as Bn, CountValueType as Br, InitialMutationState as Bt, BaseOperators as C, TableOptions as Ci, CountExpression as Cn, WhereCondition as Cr, AnyRecordQuery as Ct, UntypedExpression as D, NotFoundError as Di, UnfilteredAggregateOptions as Dn, Condition as Dr, AnyQuery as Dt, TypedExpression as E, defineTable as Ei, StringAggOptions as En, CombinedCondition as Er, SelectionState as Et, DatabaseOptions as F, SqlStatement as Fi, some as Fn, OneRow as Fr, AnyMutationQuery as Ft, createTestHelpers as G, TypeOutput as Gi, asc as Gn, InSignature as Gr, HelperEffect as Gt, TestHelpers as H, TypeInput as Hi, OrderTerms as Hn, EqualityOperator as Hr, MutationQuery as Ht, TransactionOptions as I, TransactionFailure as Ii, stringAgg as In, OneValueRows as Ir, ConflictActionRequired as It, SynchronousResult as J, AnyColumn as Ji, ColumnRefs as Jn, ComparisonSignature as Jr, CaseCondition as Jt, AnyTransformedQuery as K, TypeTransform as Ki, desc as Kn, equalityOperators as Kr, defineHelper as Kt, createDatabase as L, createStatement as Li, sum as Ln, QueryResult as Lr, ConflictKeyRequired as Lt, DbOf as M, Connection as Mi, every as Mn, or as Mr, InitialSqlQueryState as Mt, DbQueryState as N, Driver as Ni, max as Nn, ExistsValueType as Nr, SqlQuery as Nt, AnyDb as O, RequiredRelationError as Oi, UnfilteredStringAggOptions as On, ConditionOperand as Or, SelectQueryKind as Ot, Database as P, DriverResult as Pi, min as Pn, FilteredRows as Pr, SqlQueryState as Pt, MergeRelations as Q, ToColumn as Qi, BoundSelectQuery as Qn, OperandUses as Qr, TypedOperand as Qt, TransactionCoordinator as R, AnyType as Ri, OrderColumns as Rn, ResultByRows as Rr, ConflictTarget as Rt, AnyExpression as S, TableKeys as Si, AggregateOptions as Sn, WhereCallback as Sr, defineSchema as St, ExpressionOperators as T, createTableFactory as Ti, GroupValue as Tn, WhereValues as Tr, RecordQueryState as Tt, TestHooks as U, TypeOperators as Ui, Ordering as Un, EqualityOperators as Ur, MutationQueryState as Ut, TestFixture as V, Type as Vi, OrderTerm as Vn, CompileOptions as Vr, InsertMutationState as Vt, TestTransactionOptions as W, TypeOptions as Wi, SelectedRefs as Wn, HasEquality as Wr, Helper as Wt, TransformedQueryState as X, ColumnAttributes as Xi, RelationRefs as Xn, OperandValue as Xr, FollowingOperand as Xt, TransformedQuery as Y, Column as Yi, QueryContext as Yn, Operand as Yr, CaseValue as Yt, DeclaredRelations as Z, KeyKind as Zi, AnySelectQuery as Zn, compare as Zr, NullSkippingResult as Zt, TextOperators as _, ColumnValues as _i, SelectionResult as _n, KeyCheck as _r, Schema as _t, sql as a, OperatorSignature as aa, InitialQueryState as ai, ColumnFieldTypes as an, InsertValues as ar, RelationKeys as at, NumberTypeOperators as b, Table as bi, literal as bn, PrimaryKeyValues as br, SchemaTables as bt, MatchResult as c, QueryValueType as ci, GroupOperandValue as cn, UpsertValues as cr, SchemaContext as ct, defineExpression as d, TableQueryState as di, GroupedRecord as dn, FoundState as dr, TableRelations as dt, MergeOperators as ea, TypedScalarQuery as ei, TypedOperandOperators as en, SelectQuery as er, OneRelationKeys as et, FALSE as f, AnyTable as fi, MergeSelection as fn, GroupedState as fr, UsableRelation as ft, TextLengthSignature as g, ColumnShape as gi, SelectionFieldTypes as gn, GroupTerms as gr, AnySchema as gt, TextConversionSignature as h, ColumnOperators as hi, Selection as hn, GroupTerm as hr, one as ht, param as i, GenericOperatorImplementation as ia, Grouped as ii, least as in, ConflictUpdateSet as ir, RelationKey as it, DbMutationState as j, ResultRows as ji, countDistinct as jn, not as jr, FieldTypes as jt, BindOptions as k, ResultDecodeError as ki, avg as kn, Predicate as kr, AnySqlQuery as kt, NotAColumn as l, SelectQueryState as li, GroupSelectionResult as ln, FilteredStateRows as lr, SchemaRelations as lt, PatternSignature as m, ColumnDefinitions as mi, SelectedFieldTypes as mn, RowLockOptions as mr, many as mt, SqlTemplate as n, OperatorDefinitions as na, EmptyRecord as ni, coalesce as nn, from as nr, RelationDeclaration as nt, ColumnRefKey as o, defineGenericOperator as oa, QueryState as oi, ExpressionInput as on, UpdateSet as or, RelationKind as ot, TRUE as p, AnyTableKeys as pi, NestedQuery as pn, SelectedOperandType as pr, UsedRelation as pt, NotSynchronous as q, defineType as qi, orderBy as qn, BooleanResult as qr, CaseBranch as qt, identifier as r, GenericOperator as ra, FoundKey as ri, greatest as rn, ColumnValue as rr, RelationDeclarations as rt, MatchCheck as s, QueryStateOf as si, ExpressionValue as sn, UpdateValues as sr, RequiredMember as st, toSnakeCase as t, NoOperators as ta, ValuesQuery as ti, caseWhen as tn, SingletonInsertMany as tr, Relation as tt, matches as u, SingletonQueryState as ui, GroupedField as un, FoundQueryState as ur, TableContext as ut, TextTypeOperators as v, KeyColumns as vi, SelectionUses as vn, NotAKey as vr, SchemaPart as vt, Expression as w, ToColumns as wi, GroupAggregateExpression as wn, WhereFilter as wr, RecordQuery as wt, orderingOperators as x, TableFactoryOptions as xi, AggregateExpression as xn, EqValue as xr, Tables as xt, textOperators as y, Selectable as yi, Literal as yn, PrimaryKeyColumn as yr, SchemaPartRelations as yt, OpenedTestFixture as z, BaseType as zi, OrderDirection as zn, ValueRows as zr, InitialInsertState as zt };