kern-orm 0.0.0-stage → 0.1.0

package/dist/expression-Bc-s_0qJ.d.mts

@@ -0,0 +1,2091 @@
+declare const operatorSignature: unique symbol;
+/** Runtime mark of generic operators. */
+declare const genericOperatorBrand: unique symbol;
+/**
+ * Signature of a generic operator: its method on an expression of values `T` that accepts compared values `I`.
+ *
+ * An interface extending it declares `method` with `this["T"]` and `this["I"]`, such as `(value: Operand<this["T"], this["I"]>) => Expression<boolean>`.
+ */
+interface OperatorSignature {
+  readonly T: unknown;
+  readonly I: unknown;
+  readonly method: (...args: any[]) => unknown;
+}
+/**
+ * Method of signature `S` on an expression of values `T` accepting values `I`.
+ *
+ * A signature reads the value types from `this`, because TypeScript cannot instantiate a generic function type with type arguments.
+ */
+type ApplySignature<S extends OperatorSignature, T, I> = (S & {
+  readonly T: T;
+  readonly I: I;
+})["method"];
+/** Implementation of a generic operator of signature `S`: the expression it is called on, followed by the call arguments. */
+type GenericOperatorImplementation<S extends OperatorSignature, Self extends AnyExpression = AnyExpression> = (self: Self, ...args: Parameters<ApplySignature<S, unknown, unknown>>) => ReturnType<ApplySignature<S, unknown, unknown>>;
+/** Operator created by `defineGenericOperator`, whose method has signature `S` on the expression it is called on. */
+interface GenericOperator<S extends OperatorSignature, Self extends AnyExpression = AnyExpression> extends GenericOperatorImplementation<S, Self>, GenericOperatorSignature<S> {}
+/** Inference metadata of a generic operator, independent of its callable implementation. */
+interface GenericOperatorSignature<S extends OperatorSignature> {
+  readonly [genericOperatorBrand]: true;
+  /** Signature for type inference; absent at runtime. */
+  readonly [operatorSignature]?: S;
+}
+/**
+ * Defines a generic operator: one definition for every type, which works with the values of the expression it is called on.
+ *
+ * It receives the expression with its own type, including a type derived with `transform`, and its method has signature `S` with the value types of the expression, such as `lt` of `orderingOperators`.
+ * An operator defined as a plain function works with the values of the type it was added to instead.
+ * `Self` restricts the types it can be added to with `withOperators`; derived types keep the operator after `transform`.
+ */
+declare function defineGenericOperator<S extends OperatorSignature, Self extends AnyExpression = AnyExpression>(implementation: GenericOperatorImplementation<S>): GenericOperator<S, Self>;
+/** Operator implementations by name; each receives the expression it is called on, followed by the call arguments. */
+type OperatorDefinitions<Self = any> = Record<string, (self: Self, ...args: any[]) => unknown>;
+/** Empty set of operators, of an expression with the base operators only. */
+type NoOperators = Record<never, never>;
+/** Operators `O` replacing operators of `A` with the same names. */
+type MergeOperators<A extends OperatorDefinitions, O extends OperatorDefinitions> = Omit<A, keyof O> & O;
+/** Operator methods of an expression of type `T` accepting values of type `I`, without the expression parameter of their definitions. */
+type BoundOperators<O extends OperatorDefinitions, T, I = T> = { [K in keyof O]: O[K] extends GenericOperatorSignature<infer S> ? ApplySignature<S, T, I> : O[K] extends ((self: any, ...args: infer A) => infer R) ? (...args: A) => R : never; };
+/** 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.
+ *
+ * Without `strictNullChecks`, `null` belongs to every type, so every column looks nullable; the type then names the option instead.
+ */
+type NullablePrimaryKey = null extends string ? StrictNullChecksRequired : NullableKeyColumn;
+/** Type that `NullablePrimaryKey` names for a column whose type is nullable. */
+interface NullableKeyColumn {
+  readonly "primary key columns must not be nullable": never;
+}
+/** Type that `NullablePrimaryKey` names without `strictNullChecks`. */
+interface StrictNullChecksRequired {
+  readonly "kern-orm requires strictNullChecks": never;
+}
+/**
+ * Attributes that a column adds to its type in a table.
+ *
+ * `Key` is the kind of the key that the column forms alone, or `undefined` for none, and `Default` tells whether the database gives the column a value when an insert omits it.
+ */
+interface ColumnAttributes<Key extends KeyKind | undefined = KeyKind | undefined, Default extends boolean = boolean> {
+  /** Physical column name; the column key is used when it is not set. */
+  readonly name: string | undefined;
+  readonly keyKind: Key;
+  /** Whether the database gives the column a value when an insert omits it, such as by `DEFAULT` or an identity. */
+  readonly hasDefault: Default;
+}
+/**
+ * Column of a table: a type with column attributes, forming a key of kind `Key` alone, or no key for `undefined`, with a value of the database when an insert omits it if `Default` is `true`.
+ *
+ * A column is not a type, so SQL fragments and parameters reject it; its methods add attributes and return a new column.
+ */
+declare class Column<T extends AnyType, Key extends KeyKind | undefined = KeyKind | undefined, Default extends boolean = boolean> {
+  readonly type: T;
+  readonly attributes: ColumnAttributes<Key, Default>;
+  constructor(type: T, attributes: ColumnAttributes<Key, Default>);
+  /** 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>;
+  /** 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. */
+  hasDefault(): Column<T, Key, true>;
+}
+/** Column of any type. */
+type AnyColumn = Column<any>;
+/** Column of a column definition: the column itself, or a column of a type without attributes. */
+type ToColumn<D extends AnyType | AnyColumn> = D extends AnyColumn ? D : D extends AnyType ? Column<D, undefined, false> : never;
+declare const typeValues: unique symbol;
+/** Runtime mark of types, which tells them apart from columns and other objects. */
+declare const typeBrand: unique symbol;
+/**
+ * SQL type: a PostgreSQL type, the JavaScript representation of its values, and the operators of its expressions.
+ *
+ * A type is shared by columns, parameters, and SQL expressions, so the same value is encoded and decoded identically everywhere.
+ * In a table, a type is a column; `columnName`, `primaryKey`, `unique`, and `hasDefault` create a column of the type with these attributes.
+ * A type with PostgreSQL type parameters, such as the length of `varchar(255)`, has `with`.
+ */
+type Type<Output, Input = Output, Operators extends OperatorDefinitions = NoOperators, Parameters extends unknown[] | undefined = undefined> = BaseType<Output, Input, Operators, Parameters> & (Parameters extends unknown[] ? TypeWithParameters<Output, Input, Operators, Parameters> : unknown);
+/** Members of every type; see `Type`. */
+interface BaseType<Output, Input, Operators extends OperatorDefinitions, Parameters extends unknown[] | undefined> {
+  readonly [typeBrand]: true;
+  /** Value types for type inference; absent at runtime. */
+  readonly [typeValues]: {
+    output: Output;
+    input: Input;
+    operators: Operators;
+  };
+  /** SQL type name used in DDL, such as `numeric` or `vector(1536)`. */
+  readonly sqlType: string;
+  /**
+   * SQL type name that `param` casts its parameters to, such as `numeric` for `numeric(10,2)`.
+   *
+   * It omits type parameters, so that their precision, scale, or length do not constrain a parameter.
+   */
+  readonly castType: string;
+  /** Operators of expressions of this type, in addition to `isNull` or replacing it. */
+  readonly operators: Operators;
+  readonly isNullable: boolean;
+  /** Converts a non-null value to its PostgreSQL text representation. */
+  encode(value: NonNullable<Input>): string;
+  /** Converts a non-null PostgreSQL text representation to a value. */
+  decode(text: string): Exclude<Output, null>;
+  /**
+   * Creates a type whose expressions also have `operators`.
+   *
+   * An operator replaces a base or previously added operator with the same name.
+   * An operator defined as a function receives expressions of this type, as typed, even on the types derived from the created one, so that its arguments keep the encoding of this type.
+   * A generic operator from `defineGenericOperator`, such as `lt` of `orderingOperators`, receives the expression with its own type instead.
+   * An operator must not be named `then`, which would make expressions thenable.
+   */
+  withOperators<O extends OperatorDefinitions<Expression<Output, Operators, Input>>>(operators: O): Type<Output, Input, MergeOperators<Operators, O>, Parameters>;
+  /**
+   * Creates a type that accepts PostgreSQL type parameters with `with`.
+   *
+   * `format` returns the SQL type name with the parameters, such as `vector(1536)` for `1536`.
+   */
+  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.
+   *
+   * `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>;
+  /** 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>;
+  nullable(): Type<Output | null, Input | null, 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>;
+  /** 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. */
+  hasDefault(): Column<Type<Output, Input, Operators, Parameters>, undefined, true>;
+}
+/** Members of a type with PostgreSQL type parameters; see `Type`. */
+interface TypeWithParameters<Output, Input, Operators extends OperatorDefinitions, Parameters extends unknown[]> {
+  /** 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>;
+}
+/** Conversion between the values of a type and their new representation. */
+interface TypeTransform<Output, Input, NewOutput, NewInput> {
+  decode: (value: Output) => NewOutput;
+  encode: (value: NewInput) => Input;
+}
+/** Type of any values, operators, and parameters. */
+type AnyType = Type<any, any, any, any>;
+/** PostgreSQL text representation of a value, as types encode and decode it; `null` is SQL `NULL`. */
+type TextValue = string | null;
+/** Values that a type decodes. */
+type TypeOutput<T extends AnyType> = T[typeof typeValues]["output"];
+/** Values that a type encodes. */
+type TypeInput<T extends AnyType> = T[typeof typeValues]["input"];
+/** Operators of the expressions of a type. */
+type TypeOperators<T extends AnyType> = T[typeof typeValues]["operators"];
+/** Type definition. */
+interface TypeOptions {
+  /** SQL type name, such as `ltree`; `withParameters` adds type parameters to it, and a name with them requires `castType`. */
+  sqlType: string;
+  /** SQL type name that `param` casts parameters to when `sqlType` constrains values, such as `bpchar` for `char`, whose length is 1. */
+  castType?: string;
+}
+/**
+ * Defines a type whose values are the PostgreSQL text representations as they are.
+ *
+ * `transform` converts them to other values, such as `number[]` for `vector`.
+ */
+declare function defineType(options: TypeOptions): Type<string>;
+/** SQL statement ready for a driver. */
+interface SqlStatement {
+  readonly text: string;
+  /** Text representations of the parameters; PostgreSQL infers their types from the statement text. */
+  readonly parameters: readonly TextValue[];
+}
+/** Creates a statement from SQL text and the text representations of its parameters, such as `createStatement("BEGIN")`. */
+declare function createStatement(text: string, parameters?: readonly TextValue[]): SqlStatement;
+/** Result of a statement. */
+interface DriverResult {
+  /** Command tag that PostgreSQL completed the statement with, such as `SELECT` or `ROLLBACK` for a `COMMIT` of a failed transaction. */
+  readonly command: string;
+  /** Number of rows that the command tag reports, such as the rows that an `UPDATE` changes, also without `RETURNING`; `0` for a command without one, such as `BEGIN`. */
+  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[];
+  /** Rows as PostgreSQL text representations of their values, in the order of the result columns. */
+  readonly rows: readonly (readonly TextValue[])[];
+}
+/**
+ * Physical database access: transport, pooling, and connections.
+ *
+ * A driver sends parameters as text without a declared type, so that the statement text alone determines their types, and returns values as text without parsing them.
+ */
+interface Driver {
+  /** Executes a statement on any pooled connection. */
+  execute(statement: SqlStatement): Promise<DriverResult>;
+  /** Executes a script of statements without parameters, such as DDL separated by semicolons, on any pooled connection, where PostgreSQL runs them in one implicit transaction. */
+  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. */
+  close(): Promise<void>;
+}
+/** Connection reserved by a driver, such as for a transaction. */
+interface Connection {
+  /**
+   * Executes a statement on the connection.
+   *
+   * Statements and scripts run one at a time in the order of calls, so a statement sent before `COMMIT` or `ROLLBACK` completes before it.
+   */
+  execute(statement: SqlStatement): Promise<DriverResult>;
+  /** Executes a script of statements without parameters on the connection, in the order of calls with its statements. */
+  executeScript(text: string): Promise<void>;
+  /**
+   * Returns the connection to the pool after a transaction on it.
+   *
+   * Without `failure`, the transaction ended with a completed `COMMIT` or `ROLLBACK`, and the connection is idle.
+   * With `failure`, its `BEGIN`, `COMMIT`, or `ROLLBACK` failed, so the transaction may still be open: the driver returns the connection to the pool only once it is idle, and never returns a connection it lost.
+   */
+  release(failure?: TransactionFailure): void | Promise<void>;
+}
+/** Failure of the statement that started or ended a transaction on a connection. */
+interface TransactionFailure {
+  readonly error: unknown;
+}
+/** Field of a compiled result: the key of a record and how its value is decoded. */
+type ResultField = ScalarField | NestedField;
+/** Field of a value decoded by its type from its PostgreSQL text representation. */
+interface ScalarField {
+  readonly key: string;
+  readonly type: AnyType;
+  readonly nested?: undefined;
+}
+/**
+ * Field of the rows of a nested query packed as JSON, decoded by the result plan of that query.
+ *
+ * Rows `many` are an array of packed rows, and the other rows modes are one packed row or `null` without a row.
+ * A packed row is an array of the values of its fields in their order: the PostgreSQL text representation of a scalar or `null` for SQL `NULL`, and JSON for nested rows.
+ */
+interface NestedField {
+  readonly key: string;
+  readonly nested: ResultPlan;
+}
+/**
+ * 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.
+ *
+ * Without a row, a query of rows `one` rejects with `NotFoundError`, executed or nested, or with `RequiredRelationError` when a required relation guarantees the row.
+ * This mode does not imply a SQL limit: `take` and `get` add `LIMIT 1` only when they change `many` to `one`.
+ */
+type ResultRows = "many" | "one" | "nullable" | "optional";
+/** How the rows of a query become its result, apart from its fields. */
+interface ResultMode {
+  readonly rows: ResultRows;
+  /** A row is the value of its only field instead of a record. */
+  readonly value: boolean;
+}
+/** Fields of the rows of a query and how its rows become its result. */
+interface ResultPlan extends ResultMode {
+  /** Fields of a row, in the order of its values. */
+  readonly fields: readonly ResultField[];
+  /** Required relation that guarantees the row of nested rows `one`, such as `field.form`, whose missing row is a `RequiredRelationError` rather than a `NotFoundError`. */
+  readonly guaranteedBy?: string | undefined;
+}
+/** 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 {
+  readonly name = "NotFoundError";
+  /** Path of the missing nested rows from the result field that holds them, such as `user` or `fields[2].form`, after the index of the row of an executed query of rows `many`, such as `[2].form`; `undefined` when the executed query itself finds no row. */
+  readonly path: string | undefined;
+  constructor(message: string, path?: string);
+}
+/**
+ * Error thrown when a required relation, such as `field.form`, has no record for a row.
+ *
+ * A required relation promises the record, so its absence means that the database breaks the promise, such as without a foreign key, or that the relation should not be required.
+ */
+declare class RequiredRelationError extends Error {
+  /** Relation by the key of its table and its name, such as `field.form`. */
+  readonly relation: string;
+  /** 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`. */
+  readonly path: string;
+  readonly name = "RequiredRelationError";
+  constructor(
+  /** Relation by the key of its table and its name, such as `field.form`. */
+  relation: string,
+  /** 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. */
+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. */
+  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: string | undefined, options?: ErrorOptions);
+}
+/** Tells whether `T` is `any`: only `any` turns `1 & T` into a type that `0` extends. */
+type IsAny<T> = 0 extends 1 & T ? true : false;
+/** Flattens an intersection of object types into one object type, so that editors show its fields; `any` stays `any`. */
+type Simplify<T> = IsAny<T> extends true ? T : { [K in keyof T]: T[K]; } & {};
+/** Tells whether `T` is a union of several types. */
+type IsUnion<T, Whole = T> = T extends unknown ? ([Whole] extends [T] ? false : true) : false;
+/** Column definitions by their keys: types or columns; a key must not start with `$`, which is reserved for members of column references in queries. */
+type ColumnDefinitions = Record<string, AnyType | AnyColumn>;
+/** Columns by their keys. */
+type ColumnShape = Record<string, AnyColumn>;
+/** Columns of column definitions, with a column of every type without attributes. */
+type ToColumns<D extends ColumnDefinitions> = { [K in keyof D]: ToColumn<D[K]>; };
+/** Column keys of a key of a table, in its order. */
+type KeyColumns = readonly [string, ...string[]];
+declare const keysType: unique symbol;
+/**
+ * Keys of a table: its primary key, or `undefined` without one, and its other unique keys.
+ *
+ * This type does not tell which keys a table has, such as for a table typed as `Table<Name, Columns>`; `TableKeys` does.
+ */
+interface AnyTableKeys {
+  readonly primaryKey: KeyColumns | undefined;
+  readonly unique: readonly KeyColumns[];
+}
+/** Keys of a table that its type tells: primary key `PrimaryKey`, or `undefined` without one, and each unique key of `UniqueKey`. */
+interface TableKeys<PrimaryKey extends KeyColumns | undefined, UniqueKey extends KeyColumns> extends AnyTableKeys {
+  readonly [keysType]: (primaryKey: PrimaryKey, unique: UniqueKey) => readonly [PrimaryKey, UniqueKey];
+}
+/**
+ * Immutable table descriptor: physical name, columns, and keys.
+ *
+ * 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> {
+  readonly kind: "table";
+  readonly name: Name;
+  readonly columns: Columns;
+  readonly keys: Keys;
+}
+/** 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.
+ *
+ * The columns of the primary key are of `PrimaryKeyColumn`.
+ */
+interface TableOptions<Column extends string = string, PrimaryKeyColumn extends string = Column> {
+  /** Columns of a primary key of several columns; mark a primary key of one column with `primaryKey()`. */
+  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[]])[];
+}
+/** Record shape returned when all columns of a table are selected. */
+type Selectable<T extends AnyTable> = { [K in keyof T["columns"]]: TypeOutput<T["columns"][K]["type"]>; };
+/** Input values of the types of the columns. */
+type ColumnValues<T extends AnyTable> = { [K in keyof T["columns"]]: TypeInput<T["columns"][K]["type"]>; };
+/** Operators of the expressions of a column. */
+type ColumnOperators<T extends AnyTable, K extends keyof T["columns"]> = TypeOperators<T["columns"][K]["type"]>;
+/**
+ * Tells whether columns `Columns`, a union of column keys, are exactly a key of table `T`, primary or unique, in any order.
+ *
+ * It is `boolean` when the type of `T` does not tell its keys.
+ * A union of tables, or of their keys, gives the union of their results.
+ */
+type IsKey<T extends AnyTable, Columns> = T extends AnyTable ? KeysResult<T["keys"], Columns, "exact"> : never;
+/** Tells whether columns `Columns`, a union of column keys, include a key of table `T`, primary or unique, as `IsKey` tells its results. */
+type ContainsKey<T extends AnyTable, Columns> = T extends AnyTable ? KeysResult<T["keys"], Columns, "included"> : never;
+/** Tells for each of keys `K` whether a key of them, primary or unique, matches columns `Columns` as `Match` tells: `"exact"` or `"included"`; `boolean` for keys whose type does not tell them. */
+type KeysResult<K extends AnyTableKeys, Columns, Match> = K extends TableKeys<infer PrimaryKey, infer UniqueKey> ? [Match extends "exact" ? MatchingKey$1<NonNullable<PrimaryKey> | UniqueKey, Columns> : IncludedKey<NonNullable<PrimaryKey> | UniqueKey, Columns>] extends [never] ? false : true : boolean;
+/** Union of the primary key and the unique keys of keys `K` of a table, or `never` where the type of `K` does not tell them. */
+type KeyOf<K extends AnyTableKeys> = K extends TableKeys<infer PrimaryKey, infer UniqueKey> ? NonNullable<PrimaryKey> | UniqueKey : never;
+/** `true` for each key of `Key` whose columns are exactly `Columns`. */
+type MatchingKey$1<Key, Columns> = Key extends KeyColumns ? [Key[number]] extends [Columns] ? [Columns] extends [Key[number]] ? true : never : never : never;
+/** `true` for each key of `Key` whose columns are among `Columns`. */
+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`, 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. */
+type KnownKeyKind<Kind> = [Kind] extends [undefined] ? undefined : [Kind] extends ["primaryKey"] ? "primaryKey" : [Kind] extends ["unique"] ? "unique" : "unknown";
+/** Column keys that the primary key in the options of a table of columns `C` may list: none when a column is marked with `primaryKey()`. */
+type PrimaryKeyOption<C extends ColumnShape> = [KeyedColumn<C, "primaryKey">] extends [never] ? NonNullableColumnKey<C> : never;
+/**
+ * Keys of a table of columns `C` and options `O`, as `defineTable` defines them, or `AnyTableKeys` where the types do not tell them.
+ *
+ * The types do not tell them for a column whose type does not tell its key, such as `Column<T>`, for several columns marked with `primaryKey()`, which `defineTable` rejects, and for options whose keys are not tuples of single column keys, such as a variable of type `TableOptions` or a union in a key or in the list of unique keys.
+ * A union of options, which may include `undefined`, gives the union of their keys.
+ */
+type DefinedKeys<C extends ColumnShape, O> = O extends unknown ? [KeyedColumn<C, "unknown">] extends [never] ? true extends IsUnion<KeyedColumn<C, "primaryKey">> ? AnyTableKeys : KeysOf<C, OptionPrimaryKey<O>, OptionUniqueKey<O>> : AnyTableKeys : never;
+/** Keys of a table of columns `C` with primary key `PrimaryKey` and unique keys `UniqueKey` of its options, which are `"unknown"` where their types do not tell them. */
+type KeysOf<C extends ColumnShape, PrimaryKey, UniqueKey> = "unknown" extends PrimaryKey | UniqueKey ? AnyTableKeys : KnownKeysOf<DefinedPrimaryKey<C, PrimaryKey>, DefinedUniqueKey<C, UniqueKey>>;
+/** Keys that a table type tells, with its primary key and unique keys computed before they become arguments of `TableKeys`. */
+type KnownKeysOf<PrimaryKey extends KeyColumns | undefined, UniqueKey extends KeyColumns> = [PrimaryKey] extends [unknown] ? TableKeys<PrimaryKey, UniqueKey> : never;
+/** Primary key of a table of columns `C`: `PrimaryKey` of its options, or of the column marked with `primaryKey()`, or `undefined`. */
+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">>;
+/** 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. */
+type OptionPrimaryKey<O> = [O["primaryKey" & keyof O]] extends [undefined] ? undefined : O extends {
+  readonly primaryKey: infer Key;
+} ? IsExactKey<Key> extends true ? Key : "unknown" : "unknown";
+/** Unique key in options `O`, `never` without them, or `"unknown"` where their type does not tell them. */
+type OptionUniqueKey<O> = [O["unique" & keyof O]] extends [undefined] ? never : O extends {
+  readonly unique: infer Keys extends readonly unknown[];
+} ? true extends IsUnion<Keys> ? "unknown" : number extends Keys["length"] ? "unknown" : true extends { [I in keyof Keys]: IsExactKey<Keys[I]> extends true ? false : true; }[number] ? "unknown" : Keys[number] : "unknown";
+/** Tells whether key `K` is one tuple of fixed length with one column key in each position, rather than a union. */
+type IsExactKey<K> = true extends IsUnion<K> ? false : K extends readonly unknown[] ? number extends K["length"] ? false : true extends { [I in keyof K]: IsUnion<K[I]>; }[number] ? false : true : 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.
+ */
+declare function defineTable<Name extends string, Definitions extends ColumnDefinitions>(name: Name, definitions: Definitions): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, undefined>>;
+/**
+ * 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`; `null` is matched with `isNull` instead. */
+type Operand<T, I = T> = NonNullable<I> | AnyExpression<NonNullable<T> | null>;
+/** SQL value of an operand, unwrapping an expression. */
+type OperandValue<V> = V extends AnyExpression<infer T> ? T : 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 or another expression, 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;
+}
+/** Signature of `in`: membership in a list of operands of the expression type; an empty list yields `FALSE`. */
+interface InSignature extends OperatorSignature {
+  readonly method: <const L extends readonly Operand<this["T"], this["I"]>[]>(list: L) => Expression<L extends readonly [] ? boolean : BooleanResult<this["T"] | OperandValue<L[number]>>>;
+}
+/** Operators of `equalityOperators`. */
+type EqualityOperators = {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
+};
+/** Tells whether operators `O` include an operator of `equalityOperators`, so that their type has SQL `=`. */
+type HasEquality<O> = true extends { [K in keyof O]: O[K] extends {
+  readonly [equalityBrand]: true;
+} ? true : false; }[keyof O] ? true : false;
+/**
+ * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+ *
+ * A type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
+ */
+declare const equalityOperators: EqualityOperators;
+/** Records of a query without selected fields. */
+type EmptyRecord = Record<never, never>;
+/** State of a query in types: the record or value of its rows, how its rows become its result, and the relations it selects records of. */
+interface QueryState extends ResultMode {
+  /** Record of a row, or the value of its only field for a query made by `get`, `pluck`, or an aggregate method, such as `count`. */
+  readonly result: unknown;
+  /** Relations whose records the query and the queries nested in it select, which a `Db` must have. */
+  readonly uses: UsedRelation;
+}
+/**
+ * State of a select query in types: its table, the relations of its schema, the record or value of its rows and the values that its value accepts, how its rows become its result, and the relations it selects records of.
+ *
+ * Methods change only their own parts of the state.
+ */
+interface SelectQueryState extends QueryState {
+  readonly table: AnyTable;
+  readonly schema: SchemaContext;
+  /** Values that the type of the value of a query of values encodes, such as the fallback of `coalesce`; `never` for a query of records. */
+  readonly input: unknown;
+  /**
+   * Whether a required relation guarantees the row of the query, such as of `field.form`.
+   *
+   * The relation does not guarantee a record that also passes a filter, so `where`, `find`, and `findBy` end the guarantee and make rows `one` `nullable`, or `optional` for a query of values; `optional`, `nullable`, and `required` end it as well.
+   * The callback of a helper starts with it, so that the effect of the helper records whether the callback filters.
+   */
+  readonly guaranteed: boolean;
+  /** Whether the query is made by an aggregate method, such as `count`, which makes `get`, `pluck`, and the aggregate methods reject it. */
+  readonly aggregate: boolean;
+}
+/** State of a query over table `T` with schema context `C`, whatever its result. */
+interface QueryStateOf<T extends AnyTable, C extends SchemaContext = SchemaContext> extends SelectQueryState {
+  readonly table: T;
+  readonly schema: C;
+}
+/**
+ * State of a query that starts from table `T` with schema context `C`: rows as records without fields, all of them or of the records of relation `U` when given, in rows mode `Rows`, guaranteed by a required relation when `Guaranteed`.
+ *
+ * Without relations in `C`, it also types a query of the table in a schema that has relations of the table.
+ */
+interface InitialQueryState<T extends AnyTable, C extends SchemaContext = NoRelations, U extends UsedRelation = never, Rows extends ResultRows = "many", Guaranteed extends boolean = false> extends QueryStateOf<T, C> {
+  readonly result: EmptyRecord;
+  readonly input: never;
+  readonly rows: Rows;
+  readonly value: false;
+  readonly uses: U;
+  readonly guaranteed: Guaranteed;
+  readonly aggregate: false;
+}
+/** Selection of the rows of a nested query as the value of the field `key`. */
+interface NestedSelectionNode {
+  readonly key: string;
+  readonly query: QueryNode;
+  /** `Db` that the nested query is bound to, which must be the `Db` that runs the statement. */
+  readonly db: AnyDb | undefined;
+}
+/** Field selected by a query: an expression, or the rows of a nested query. */
+type SelectedNode = ProjectionNode | NestedSelectionNode;
+/** Select query of a table; its result mode applies when it is executed or its rows are nested. */
+interface QueryNode extends ResultMode {
+  readonly kind: "query";
+  readonly from: TableSourceNode;
+  /** Relation whose records the query selects, correlated with its parent by the relation filter. */
+  readonly relation: RelationDefinition | undefined;
+  /** 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;
+  readonly orderBy: readonly OrderNode[];
+  readonly limit: ExpressionNode | undefined;
+  readonly offset: ExpressionNode | 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;
+}
+/**
+ * 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.
+ *
+ * Its result mode is the rows mode of the rows it changes and whether a row is the value of its only field.
+ */
+type MutationNode = MutationStatementNode<SelectedNode>;
+/** Query of `$select` without a source: one record whose fields are the values of expressions and the rows of independent queries. */
+interface RecordQueryNode {
+  readonly kind: "record";
+  /** Fields in the order of the record, with unique keys. */
+  readonly projections: readonly SelectedNode[];
+}
+/** Rows mode of a query of a relation of kind `Kind`: `many`, or one row, `nullable` unless `Required` is `true`; a union gives the union of their modes. */
+type RelationRows<Kind extends RelationKind, Required extends boolean> = Kind extends "many" ? "many" : Required extends true ? "one" : "nullable";
+/** Rows mode after a filter of a query whose row a required relation guarantees: `one` becomes `nullable`, or `optional` for a query of values; other modes stay. */
+type FilteredRows<Rows extends ResultRows, Value extends boolean> = Rows extends "one" ? Value extends true ? "optional" : "nullable" : Rows;
+/** Rows mode after `take`: `many` becomes `one`; the modes of one row stay. */
+type OneRow<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows;
+/** Rows mode after `pluck`: `nullable` becomes `optional`; the other modes stay. */
+type ValueRows<Rows extends ResultRows> = Rows extends "nullable" ? "optional" : Rows;
+/** Rows mode after `get`: `many` becomes `one` and `nullable` becomes `optional`; `one` and `optional` stay. */
+type OneValueRows<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows extends "nullable" ? "optional" : Rows;
+/**
+ * Result of a query of state `S`, executed or nested: an array of records or values, or one of them, `null` or `undefined` when a query of rows `nullable` or `optional` finds no row.
+ *
+ * It is the union of the results of every state that `S` allows, such as of a union of rows modes.
+ */
+type QueryResult<S extends QueryState> = S extends QueryState ? ResultByRows<S["result"], S["rows"]> : never;
+/** Result of rows of `Result` returned in rows mode `Rows`; a union of modes gives the union of their results. */
+type ResultByRows<Result, Rows extends ResultRows> = Rows extends "many" ? Result[] : Rows extends "one" ? Result : Rows extends "nullable" ? Result | null : Result | undefined;
+/** References to the columns of the query source, passed to query callbacks. */
+type ColumnRefs<T extends AnyTable> = { readonly [K in keyof T["columns"]]: Expression<Selectable<T>[K], ColumnOperators<T, K>, ColumnValues<T>[K]>; };
+/**
+ * Queries of the records of the relations of the table of schema context `C`, by relation name, which the callback of `select` receives 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 `select` have as their own properties and which read the key columns from them. */
+  readonly relations: PropertyDescriptorMap;
+}
+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 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> | 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] : EqOperand<ColumnRefs<T>[K]>;
+/** Operand of the `eq` operator of an expression, if it has one taking a single operand. */
+type EqOperand<E> = E extends {
+  eq: (value: infer V) => Predicate;
+} ? V : never;
+/** Filter of `where`: a Boolean expression, an object of column values, or their combination with `and`, `or`, and `not`. */
+type WhereCondition<T extends AnyTable> = ConditionOperand<WhereValues<T>>;
+/** Argument of `where`: a condition, or a callback that receives the columns of the query and returns one. */
+type WhereFilter<T extends AnyTable> = WhereCondition<T> | ((columns: ColumnRefs<T>) => WhereCondition<T>);
+/**
+ * Defines a reusable condition of `where` for queries over a table, checking its objects of column values against the columns.
+ *
+ * The condition can be combined further with `and`, `or`, and `not`.
+ */
+declare function defineFilter<T extends AnyTable>(table: TableOrQuery<T>, filter: NoInfer<WhereCondition<T>>): WhereCondition<T>;
+/**
+ * Defines a reusable callback of `where` for queries over a table, checking its objects of column values against the columns.
+ *
+ * Another callback can call it with its columns.
+ */
+declare function defineFilter<T extends AnyTable>(table: TableOrQuery<T>, filter: NoInfer<(columns: ColumnRefs<T>) => WhereCondition<T>>): (columns: ColumnRefs<T>) => WhereCondition<T>;
+/** Defines a reusable filter of `where` for queries over a table, either a condition or a callback. */
+declare function defineFilter<T extends AnyTable>(table: TableOrQuery<T>, filter: NoInfer<WhereFilter<T>>): WhereFilter<T>;
+/**
+ * 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 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, sorted in ascending order, or an expression with a direction. */
+type OrderTerm = AnyExpression | Ordering;
+/**
+ * References of the callback of `orderBy` to the fields of records `R` selected by a query: their expressions by key.
+ *
+ * A field of a nested query, such as of nested rows or of an aggregate, is among them in types, but reading it throws.
+ */
+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 `expression` in ascending order, in the callback of `orderBy`. */
+declare function asc(expression: AnyExpression): Ordering;
+/** Sorts by `expression` in descending order, in the callback of `orderBy`. */
+declare function desc(expression: AnyExpression): Ordering;
+/** Sorts by `expression` in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
+declare function orderBy(expression: AnyExpression, 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, or an expression of its values. */
+type ColumnValue<T extends AnyTable, K extends keyof T["columns"]> = ColumnValues<T>[K] | AnyExpression<Selectable<T>[K]>;
+/** Key of a column of table `T` that an insert may omit, which gets its default: one that the database gives a value, as `hasDefault` marks it, or a nullable one, whose default is `NULL` unless the database declares another. */
+type OptionalColumnKey<T extends AnyTable> = { [K in keyof T["columns"]]: T["columns"][K]["attributes"]["hasDefault"] extends true ? K : null extends ColumnValues<T>[K] ? K : never; }[keyof T["columns"]];
+/** Record of an insert into table `T`: the values of its columns, which may omit a column with a default or a nullable column, or give it as `undefined`. */
+type InsertValues<T extends AnyTable> = { readonly [K in keyof T["columns"] as K extends OptionalColumnKey<T> ? never : K]: ColumnValue<T, K>; } & { readonly [K in OptionalColumnKey<T>]?: ColumnValue<T, K> | undefined; };
+/** Values of the columns of table `T` that an update sets; a column omitted or given as `undefined` keeps its value. */
+type UpdateValues<T extends AnyTable> = { readonly [K in keyof T["columns"]]?: ColumnValue<T, K> | undefined; };
+/** Argument of `update`: the values that it sets, or a callback that receives the columns of the changed rows and returns them. */
+type UpdateSet<T extends AnyTable> = UpdateValues<T> | ((columns: ColumnRefs<T>) => UpdateValues<T>);
+/** State `S` with the parts of `Changes` replaced. */
+type ChangeState<S extends SelectQueryState, Changes extends Partial<SelectQueryState>> = { readonly [K in keyof SelectQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
+/** 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. */
+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>;
+/** State of a query whose rows are records, which `select` and `clearSelect` change. */
+type RecordQueryState$1 = SelectQueryState & {
+  readonly value: false;
+};
+/** State of a query whose row no relation guarantees, which a filter keeps. */
+type UnguaranteedQueryState = SelectQueryState & {
+  readonly guaranteed: false;
+};
+/** State of a query whose rows are values, made by `get`, `pluck`, or an aggregate method, such as `count`. */
+type ValueQueryState = SelectQueryState & {
+  readonly value: true;
+};
+/** State of a query not made by an aggregate method, which `get`, `pluck`, and the aggregate methods apply to. */
+type UnaggregatedQueryState = SelectQueryState & {
+  readonly aggregate: false;
+};
+/** State of a query of the value `V` of an aggregate over the rows of a query of state `S`, which always returns one row, accepting values `I` in place of its value. */
+type AggregateState<S extends SelectQueryState, V, I> = ChangeState<S, {
+  result: V;
+  input: I;
+  rows: "one";
+  value: true;
+  guaranteed: false;
+  aggregate: true;
+}>;
+/** Value `V` of a query of values whose `NULL` `coalesce` replaces with fallback `F`. */
+type CoalescedValue<V, F> = Exclude<V, null> | (F extends AnyExpression<infer T> ? Extract<T, null> : never);
+/** State of a query of many rows, which `limit` and `offset` apply to. */
+type ManyRowsQueryState = SelectQueryState & {
+  readonly rows: "many";
+};
+/** 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. */
+type OneRecordQueryState = OneRowQueryState & {
+  readonly value: false;
+};
+/**
+ * Immutable select query of state `S`, unbound or bound to a `Db`.
+ *
+ * Every method returns a query of the same kind and leaves this query unchanged.
+ * 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 SelectQuery<out S extends SelectQueryState, out Kind extends SelectQueryKind = "unbound"> {
+  readonly table: S["table"];
+  readonly node: QueryNode;
+  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  readonly context: QueryContext;
+  readonly types: S;
+  /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+  readonly db: QueryDb<Kind>;
+  /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+  readonly then: QueryThen<S, Kind>;
+  constructor(table: S["table"], node: QueryNode,
+  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  context: QueryContext, db?: AnyDb);
+  /** Adds a filter combined with `AND` with the previous ones. */
+  where<Q extends QueryOf<UnguaranteedQueryState>>(this: Q, filter: WhereFilter<Q["types"]["table"]>): Q;
+  /**
+   * Adds a filter combined with `AND` with the previous ones.
+   *
+   * A query of the record of a required relation, such as `field.form`, resolves to `null` without a record that passes the filter, or to `undefined` after `get` or `pluck`.
+   */
+  where<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, filter: WhereFilter<S["table"]>): SelectQuery<FilteredState<S>, Kind>;
+  /** Selects all columns of the table, replacing fields under their keys. */
+  select<S extends RecordQueryState$1, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, all: "*"): SelectQuery<ChangeState<S, {
+    result: MergeSelection<S["result"], Selectable<S["table"]>>;
+  }>, Kind>;
+  /** Selects the listed columns, replacing fields under their keys. */
+  select<S extends RecordQueryState$1, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, ...keys: K[]): SelectQuery<ChangeState<S, {
+    result: MergeSelection<S["result"], Pick<Selectable<S["table"]>, K>>;
+  }>, Kind>;
+  /**
+   * Selects the expressions and nested queries returned by `callback`, replacing fields under their keys.
+   *
+   * `callback` receives the columns and the queries of the relations of the table.
+   * Each expression is decoded with its type, so it must have one: a column, an operator result, or a fragment of `sql(type)`, but not of `sql<T>`.
+   * A nested query is unbound, such as a query of a relation, or bound to the `Db` that runs the query; its rows become the value of its field as they become the result of an executed query.
+   */
+  select<S extends RecordQueryState$1, Kind extends SelectQueryKind, Sel extends Selection>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => Sel): SelectQuery<ChangeState<S, {
+    result: MergeSelection<S["result"], SelectionResult<Sel>>;
+    uses: S["uses"] | SelectionUses<Sel>;
+  }>, Kind>;
+  /** Removes all selected fields and keeps the other clauses. */
+  clearSelect<S extends RecordQueryState$1, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
+    result: 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`.
+   * When a required relation still guarantees the row, such as of `field.form`, it rejects with `RequiredRelationError` instead.
+   *
+   * A query of one row stays as it is.
+   */
+  take<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<ChangeState<S, {
+    rows: OneRow<S["rows"]>;
+  }>, Kind>;
+  /**
+   * Filters the query by the values of the primary key of the table, in the order of its columns, 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`.
+   */
+  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S>, 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`.
+   */
+  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>;
+  /**
+   * Replaces the selected fields with a column, limits the query to one row, and returns the value of the column instead of a record.
+   *
+   * Without a row, it rejects with `NotFoundError`, or with `RequiredRelationError` when a required relation still guarantees the row, such as of `field.form`.
+   * An optional or nullable query resolves to `undefined` without a row instead.
+   * A `NULL` value is `null`.
+   */
+  get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ChangeState<S, {
+    result: Selectable<S["table"]>[K];
+    input: ColumnValues<S["table"]>[K];
+    rows: OneValueRows<S["rows"]>;
+    value: true;
+  }>, Kind>;
+  /**
+   * Replaces the selected fields with the expression returned by `callback`, limits the query to one row, and returns the value of the expression instead of a record.
+   *
+   * Without a row, it rejects with `NotFoundError`, or with `RequiredRelationError` when a required relation still guarantees the row, such as of `field.form`.
+   * An optional or nullable query resolves to `undefined` without a row instead.
+   * A `NULL` value is `null`.
+   */
+  get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ChangeState<S, {
+    result: ExpressionValue<E>;
+    input: ExpressionInput<E>;
+    rows: OneValueRows<S["rows"]>;
+    value: true;
+  }>, Kind>;
+  /**
+   * Replaces the selected fields with a column and returns the value of the column of each row instead of a record.
+   *
+   * 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, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ChangeState<S, {
+    result: Selectable<S["table"]>[K];
+    input: ColumnValues<S["table"]>[K];
+    rows: ValueRows<S["rows"]>;
+    value: true;
+  }>, Kind>;
+  /**
+   * Replaces the selected fields with the expression returned by `callback` and returns the value of the expression for each row instead of a record.
+   *
+   * It keeps whether the query returns an array or one value, such as after `take`, and how it handles a missing row, except that a nullable query resolves to `undefined` without a row.
+   */
+  pluck<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ChangeState<S, {
+    result: ExpressionValue<E>;
+    input: ExpressionInput<E>;
+    rows: ValueRows<S["rows"]>;
+    value: true;
+  }>, Kind>;
+  /**
+   * Replaces the selected fields with the number of rows of the query and returns the number instead of the rows.
+   *
+   * It keeps the filters and ignores the order; with `limit` or `offset`, it counts the rows of that page.
+   */
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<AggregateState<S, number, number>, Kind>;
+  /** Replaces the selected fields with the number of the values of the column other than `NULL` among the rows of the query and returns it instead of the rows. */
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, number, number>, Kind>;
+  /** Replaces the selected fields with the number of the values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows. */
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, number, number>, Kind>;
+  /** Replaces the selected fields with the number of the distinct values of the column other than `NULL` among the rows of the query and returns it instead of the rows. */
+  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, number, number>, Kind>;
+  /** Replaces the selected fields with the number of the distinct values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows. */
+  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, number, number>, Kind>;
+  /** Replaces the selected fields with the smallest value of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
+  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with the smallest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
+  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /** Replaces the selected fields with the largest value of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
+  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with the largest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
+  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /** Replaces the selected fields with the sum of the values of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
+  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with the sum of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
+  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /** Replaces the selected fields with the average of the values of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values. */
+  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with the average of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values. */
+  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /** Replaces the selected fields with whether every value of the Boolean column other than `NULL` among the rows of the query is true and returns it instead of the rows, or `null` without such values. */
+  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with whether every value other than `NULL` of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without such values. */
+  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /** Replaces the selected fields with whether any value of the Boolean column among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`. */
+  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with whether any value of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`. */
+  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /** Replaces the selected fields with the values of the text column other than `NULL` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values. */
+  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K, delimiter: string): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  /** Replaces the selected fields with the values other than `NULL` of the text expression returned by `callback` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values. */
+  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E, delimiter: string): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  /**
+   * Replaces a `NULL` value of a query of values, such as one made by `get`, `pluck`, or an aggregate, with `fallback`, such as `0` for a sum without rows.
+   *
+   * `fallback` is a value that the type of the value accepts or an expression of its values, such as a column of the row of a parent query.
+   * A missing row stays missing: an optional query still resolves to `undefined` without a row.
+   */
+  coalesce<S extends ValueQueryState, Kind extends SelectQueryKind, F extends Operand<S["result"], S["input"]>>(this: SelectQuery<S, Kind>, fallback: F): SelectQuery<ChangeState<S, {
+    result: CoalescedValue<S["result"], F>;
+  }>, Kind>;
+  /**
+   * Sorts the rows by the sort keys returned by `callback`, after the sort keys of earlier calls.
+   *
+   * `callback` receives the columns and the fields selected so far, and returns an expression, sorted in ascending order, `asc`, `desc`, or `orderBy` of an expression, 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()`.
+   */
+  orderBy<Q extends QueryOf<RecordQueryState$1>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]>, 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.
+   *
+   * `callback` receives the columns and the expression of the value, and returns an expression, sorted in ascending order, `asc`, `desc`, or `orderBy` of an expression, or an array of them.
+   */
+  orderBy<Q extends QueryOf<ValueQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]>, value: AnyExpression<Q["types"]["result"]>) => 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.
+   *
+   * 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.
+   */
+  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`, or an expression, such as a `sql` fragment.
+   * Select the fields that it returns after it, such as `insert(values).get("id")`.
+   */
+  insert<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: InsertValues<S["table"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], "one">, Kind>;
+  /**
+   * 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.
+   */
+  insertMany<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, records: readonly InsertValues<S["table"]>[]): MutationQuery<InitialMutationState<S["table"], S["schema"], "many">, Kind>;
+  /**
+   * Updates the rows that the filters of the query choose with the values of `set`, and resolves to the number of the updated rows.
+   *
+   * `set` gives the values of the columns to update, or is a callback that receives the columns and returns them, such as to set a column from another one; a column omitted or given as `undefined` keeps its value.
+   * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
+   * A query without a filter must call `all` to update every row.
+   * Select the fields that it returns after it, with their values after the update, such as `update(set).select("id")`.
+   */
+  update<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, set: UpdateSet<S["table"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
+  /**
+   * 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.
+   * 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;
+  /**
+   * 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`.
+   *
+   * `callback` receives this query and `args` and returns this query or a query derived from it, which keeps the binding of this query.
+   */
+  use<Q, Kind extends SelectQueryKind, R extends SelectQuery<any, Kind>, A extends unknown[] = []>(this: Q & SelectQuery<any, Kind>, callback: (query: Q, ...args: A) => R, ...args: A): R;
+  /**
+   * 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;
+  /** Creates a query of the same kind and `Db` with the node changes applied. */
+  private derive;
+  /**
+   * Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
+   *
+   * It adds the changes of `take` to `changes`, which must leave the limit as it is.
+   */
+  private deriveTaken;
+  /** Creates the query of the value of `projection`, an aggregate over the rows of this query, which always returns one row. */
+  private deriveAggregate;
+  /** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and returns an expression; `delimiter` is the delimiter of `stringAgg`. */
+  private aggregateBy;
+  /** Returns the changes of the node that add `filter` with `AND`, ending the guarantee of the row as `FilteredState` does in types. */
+  private addFilter;
+  /** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
+  private takeWhere;
+  /** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
+  private changeOneRow;
+  /** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
+  private rejectValue;
+  /** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method. */
+  private rejectAggregate;
+}
+/** Select query bound to a `Db`, executed by awaiting it; every method returns a query bound to the same `Db`. */
+type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
+/** Select query of any state and kind. */
+type AnySelectQuery = SelectQuery<any, SelectQueryKind>;
+/** Type of a record of a query result, or of its value for a query made by `get`, `pluck`, or an aggregate method. */
+type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
+/** Table of a definition such as `defineFilter`: the table itself or a query over it with schema context `C`, such as `schema.form`. */
+type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
+/** Starts a query over a new occurrence of the table. */
+declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T>>;
+/** Expressions and nested queries selected under the keys of the result fields; a record has no symbol keys. */
+interface Selection {
+  readonly [key: string]: TypedExpression | NestedQuery;
+  readonly [key: symbol]: never;
+}
+/** Query whose rows a selection nests as the value of a field: a query of any state and kind, such as a query of a relation. */
+type NestedQuery = QueryOf<SelectQueryState>;
+/** Record of the values of the expressions and of the nested rows of a selection. */
+type SelectionResult<S extends Selection> = { [K in keyof S]: FieldValue<S[K]>; };
+/** Value of a selected field: of an expression, or of the nested rows of a query as the result of executing it, for each member of a union of them. */
+type FieldValue<V> = V extends NestedQuery ? QueryResult<V["types"]> : ExpressionValue<V>;
+/** Relations whose records the nested queries of a selection select. */
+type SelectionUses<S extends Selection> = S[keyof S] extends (infer V) ? V extends NestedQuery ? V["types"]["uses"] : never : never;
+/** Value of a selected expression. */
+type ExpressionValue<E> = E extends AnyExpression<infer T> ? T : never;
+/** Values that the type of an expression encodes, such as in place of its value. */
+type ExpressionInput<E> = E extends AnyExpression<unknown, infer I> ? I : never;
+declare const helperFields: unique symbol;
+/** Marker of the input fields of a helper, carrying the keys selected by its callback. */
+interface HelperFields<Keys extends PropertyKey = PropertyKey> {
+  readonly [helperFields]: Keys;
+}
+/** Records with `Fields` added or replaced, for each branch of either record type; `any` stays `any`. */
+type MergeSelection<Previous, Fields> = Previous extends unknown ? Fields extends unknown ? MergeFields<RecordFields<Previous>, RecordFields<Fields>> & (IsAny<Previous> extends true ? Previous : unknown) : never : never;
+/** Fields with numeric keys represented as the string keys used in result records. */
+type RecordFields<Fields> = Fields extends unknown ? [Extract<keyof Fields, number>] extends [never] ? Fields : { [K in keyof Fields as K extends number ? `${K}` : K]: Fields[K]; } : never;
+/** Merge of normalized fields, retaining the previous value when an optional replacement is absent. */
+type MergeFields<Previous, Fields> = Simplify<{ [K in keyof Previous as K extends keyof Fields ? ({} extends Pick<Fields, K> ? K : never) : K]: K extends typeof helperFields // A branch selecting extra keys must not be reduced to one selecting fewer fields or none.
+ ? Previous[K] | keyof Fields : K extends keyof Fields // A decoder can return undefined, so it cannot be excluded as merely an absent property.
+ ? Previous[K] | Fields[K] : Previous[K]; } & { [K in keyof Fields as K extends keyof Previous ? ({} extends Pick<Fields, K> ? never : K) : K]: Fields[K]; }>;
+/** State of a query of `$select` in types: one record `R`, whose nested queries select records of relations `U`. */
+interface RecordQueryState<R = unknown, U extends UsedRelation = UsedRelation> extends QueryState {
+  readonly result: R;
+  readonly rows: "one";
+  readonly value: false;
+  readonly uses: U;
+}
+/** State of the query of `$select` of `Sel`: the record of the values of its expressions and the results of its queries. */
+type SelectionState<Sel extends Selection> = RecordQueryState<MergeSelection<EmptyRecord, SelectionResult<Sel>>, SelectionUses<Sel>>;
+/**
+ * Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and the results of independent queries, selected in one statement.
+ *
+ * An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
+ * A bound query executes on its `Db` when awaited.
+ */
+declare class RecordQuery<out S extends RecordQueryState, out Kind extends SelectQueryKind = "unbound"> {
+  readonly node: RecordQueryNode;
+  readonly types: S;
+  /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+  readonly db: QueryDb<Kind>;
+  /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+  readonly then: QueryThen<S, Kind>;
+  constructor(node: RecordQueryNode, db?: AnyDb);
+  /**
+   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
+   *
+   * 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;
+}
+/** Query of `$select` of any state and kind. */
+type AnyRecordQuery = RecordQuery<any, SelectQueryKind>;
+declare const schemaBrand: unique symbol;
+/** Key of the relation definitions of a schema, which composition reads. */
+declare const schemaRelations: unique symbol;
+/** Tables by their keys; a key must not start with `$`, which is reserved for schema and `Db` members. */
+type Tables = Record<string, AnyTable>;
+/**
+ * Immutable collection of tables and their relations with query entry points.
+ *
+ * A schema is not bound to a database, so queries built from it can be defined at module level.
+ * A `Db` can execute such a query if its schema contains the tables and the selected relations of the query and every bound nested query belongs to that `Db`.
+ */
+type Schema<T extends Tables, R extends SchemaRelations = EmptyRecord> = SchemaEntries<T, R> & SchemaMembers<T, R>;
+/** Query entry points; each access starts a query over a new table occurrence. */
+type SchemaEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: SelectQuery<InitialQueryState<T[K], TableContext<R, K>>>; };
+/** Members of a schema that composition reads: its tables and the relations of its tables. */
+interface SchemaContents<T extends Tables, R extends SchemaRelations> {
+  readonly [schemaBrand]: true;
+  /** Tables of the schema by their keys. */
+  readonly $tables: T;
+  /** Relation definitions by table key and relation name. */
+  readonly [schemaRelations]: R;
+}
+interface SchemaMembers<T extends Tables, R extends SchemaRelations> extends SchemaContents<T, R> {
+  /**
+   * Creates a schema of the same tables with the relations of `relations` added, declared with `many` and `one` by their names under the keys of their tables.
+   *
+   * A relation refers to a table of the schema by columns of SQL types that `=` compares; a relation that the schema already has is rejected.
+   */
+  $relations<S extends AnySchema, D extends RelationDeclarations<S["$tables"]>>(this: S, relations: D & CheckDeclarations<S["$tables"], D>): Schema<S["$tables"], MergeRelations<S[typeof schemaRelations] & DeclaredRelations<S["$tables"], D>>>;
+  /**
+   * Starts an unbound query of one record whose fields are the values of the expressions and 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;
+}
+/** 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;
+/**
+ * Declares a relation of a table to the records 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.
+ */
+declare function many<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>>(target: Target, keys: RelationKeys<Target, From>): RelationDeclaration<"many", Source, Target, From, false>;
+/**
+ * Declares a relation of a table to the record of `target` whose columns `to` equal its columns `from`, for `$relations` of a schema.
+ *
+ * A composite key lists its columns in arrays of the same length.
+ * The columns `to` must include a key of `target`, primary or unique, so that they match at most one record.
+ * Without the record, a query of the relation gives `null`, and a query of a relation declared with `required: true` rejects unless it filters the record.
+ * Set `required: true` only where the database guarantees the record, such as by a foreign key on columns `from` that are not nullable.
+ */
+declare function one<Source extends AnyTable, Target extends AnyTable, const From extends RelationKey<Source>, const To extends MatchingKey<Target, From>, const Keys extends object = EmptyRecord>(target: Target, keys: OneRelationKeys<From, To> & RequiredMember<Keys> & TargetKeyCheck<Target, To>): RelationDeclaration<"one", Source, Target, From, NoInfer<DeclaredRequiredOf<Keys>>>;
+/**
+ * State in types of a query that inserts, updates, or deletes rows: its table and the relations of its schema, the rows mode of the rows it changes, and its result, which is their number until a selection returns their fields.
+ *
+ * Methods change only their own parts of the state.
+ */
+interface MutationQueryState extends QueryState {
+  readonly table: AnyTable;
+  readonly schema: SchemaContext;
+  /** Rows mode of the rows that the query changes, which `select`, `get`, and `pluck` return. */
+  readonly changed: ResultRows;
+  /** Whether the query returns the fields of the rows it changes rather than their number. */
+  readonly returning: boolean;
+}
+/** State of a query that inserts, updates, or deletes rows of table `T` with schema context `C` in rows mode `Rows` and returns their number. */
+interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows extends ResultRows> extends MutationQueryState {
+  readonly table: T;
+  readonly schema: C;
+  readonly changed: Rows;
+  readonly returning: false;
+  readonly result: number;
+  readonly rows: "one";
+  readonly value: true;
+  readonly uses: never;
+}
+/** State `S` of a mutation with the parts of `Changes` replaced. */
+type ChangeMutationState<S extends MutationQueryState, Changes extends Partial<MutationQueryState>> = { readonly [K in keyof MutationQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
+/** State of a mutation that returns the number of the rows it changes or their records, which `select` applies to. */
+type RecordMutationState = MutationQueryState & ({
+  readonly returning: false;
+} | {
+  readonly value: false;
+});
+/** State of a mutation of one row, which `get` applies to. */
+type OneRowMutationState = MutationQueryState & {
+  readonly changed: "one" | "nullable" | "optional";
+};
+/** Record that the returned fields of a mutation of state `S` add to: the fields selected earlier, or none. */
+type ReturnedRecord$1<S extends MutationQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
+/** State of a mutation of state `S` that returns records with `Fields`, which its nested queries select records of relations `U` for. */
+type RecordsState<S extends MutationQueryState, Fields, U extends UsedRelation = never> = ChangeMutationState<S, {
+  result: MergeSelection<ReturnedRecord$1<S>, Fields>;
+  rows: S["changed"];
+  value: false;
+  returning: true;
+  uses: S["uses"] | U;
+}>;
+/** State of a mutation of state `S` that returns value `V` of each row it changes in rows mode `Rows`. */
+type ValueState$1<S extends MutationQueryState, V, Rows extends ResultRows> = ChangeMutationState<S, {
+  result: V;
+  rows: Rows;
+  value: true;
+  returning: true;
+}>;
+/**
+ * Immutable query of state `S` that inserts, updates, or deletes rows, unbound or bound to a `Db`.
+ *
+ * Without a selection, it resolves to the number of the rows it changes; `select`, `get`, and `pluck` return the fields of those rows instead.
+ * An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
+ * A bound query executes on its `Db` when awaited.
+ */
+declare class MutationQuery<out S extends MutationQueryState, out Kind extends SelectQueryKind = "unbound"> {
+  readonly table: S["table"];
+  readonly node: MutationNode;
+  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  readonly context: QueryContext;
+  readonly types: S;
+  /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
+  readonly db: QueryDb<Kind>;
+  /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
+  readonly then: QueryThen<S, Kind>;
+  constructor(table: S["table"], node: MutationNode,
+  /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
+  context: QueryContext, db?: AnyDb);
+  /** Returns all columns of each changed row, replacing fields under their keys, instead of the number of the rows. */
+  select<S extends RecordMutationState, Kind extends SelectQueryKind>(this: MutationQuery<S, Kind>, all: "*"): MutationQuery<RecordsState<S, Selectable<S["table"]>>, Kind>;
+  /** Returns the listed columns of each changed row, replacing fields under their keys, instead of the number of the rows. */
+  select<S extends RecordMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, ...keys: K[]): MutationQuery<RecordsState<S, Pick<Selectable<S["table"]>, K>>, Kind>;
+  /**
+   * Returns the expressions and nested queries that `callback` returns for each changed row, replacing fields under their keys, instead of the number of the rows.
+   *
+   * `callback` receives the columns of the changed row, with their values after an insert or an update and those of the deleted row, and the queries of the relations of the table, as the callback of `select` of a select query does.
+   * A nested query reads the database as it was before the change, apart from the changed row.
+   */
+  select<S extends RecordMutationState, Kind extends SelectQueryKind, Sel extends Selection>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => Sel): MutationQuery<RecordsState<S, SelectionResult<Sel>, SelectionUses<Sel>>, Kind>;
+  /**
+   * Returns the value of a column of the changed row instead of the number of the rows, in a query that changes one row, such as of `insert` or `find`.
+   *
+   * A query of a nullable row resolves to `undefined` without the row.
+   */
+  get<S extends OneRowMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], OneValueRows<S["changed"]>>, Kind>;
+  /**
+   * Returns the value of the expression that `callback` returns for the changed row instead of the number of the rows, in a query that changes one row, such as of `insert` or `find`.
+   *
+   * A query of a nullable row resolves to `undefined` without the row.
+   */
+  get<S extends OneRowMutationState, Kind extends SelectQueryKind, E extends TypedExpression>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): MutationQuery<ValueState$1<S, ExpressionValue<E>, OneValueRows<S["changed"]>>, Kind>;
+  /** Returns the value of a column of each changed row instead of the number of the rows, keeping whether the query returns an array or one value. */
+  pluck<S extends MutationQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], ValueRows<S["changed"]>>, Kind>;
+  /** Returns the value of the expression that `callback` returns for each changed row instead of the number of the rows, keeping whether the query returns an array or one value. */
+  pluck<S extends MutationQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): MutationQuery<ValueState$1<S, ExpressionValue<E>, ValueRows<S["changed"]>>, Kind>;
+  /**
+   * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
+   *
+   * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
+   */
+  toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /** Creates a mutation of the same kind and `Db` with the node changes applied. */
+  private derive;
+  /** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and returns an expression, of each changed row. */
+  private deriveValue;
+}
+/** Query of any state and kind that inserts, updates, or deletes rows. */
+type AnyMutationQuery = MutationQuery<any, SelectQueryKind>;
+/** Types of the fields of the rows of a query of SQL text by the names of the result columns they decode. */
+interface FieldTypes {
+  readonly [key: string]: AnyType;
+  readonly [key: symbol]: never;
+}
+/** Record of the values that the types of fields `F` decode. */
+type DecodedFields<F extends FieldTypes> = { -readonly [K in keyof F]: TypeOutput<F[K]>; };
+/**
+ * State in types of a query of SQL text: the rows mode of the rows that its statement returns, and its result, which is the number of the rows of its command tag until a selection returns their fields.
+ *
+ * Methods change only their own parts of the state.
+ */
+interface SqlQueryState extends QueryState {
+  /** Rows mode of the rows of the statement, which `select`, `get`, and `pluck` return. */
+  readonly returned: ResultRows;
+  /** Whether the query returns the fields of the rows of the statement rather than their number. */
+  readonly returning: boolean;
+}
+/** State of a query of SQL text that returns the number of the rows of its command tag. */
+interface InitialSqlQueryState extends SqlQueryState {
+  readonly result: number;
+  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;
+  /** 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;
+/** 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. */
+  readonly data: T;
+}
+/** Test fixture opened by the transaction coordinator: an outer transaction of a database created for tests, which always rolls back when it closes. */
+interface OpenedTestFixture<T = unknown> extends AsyncDisposable {
+  /** Result of the seed of the fixture, such as the records it created; reading it after the fixture closes throws. */
+  readonly data: T;
+  /** Rolls back the fixture and the fixtures opened inside it; closing a closed fixture does nothing. */
+  close(): Promise<void>;
+}
+/** Test fixture that is being opened, with a `close` that can be called before it opens. */
+interface PendingTestFixture<T = unknown> {
+  readonly fixture: Promise<OpenedTestFixture<T>>;
+  close(): Promise<void>;
+}
+/**
+ * Hooks of a test runner that run a function before and after the tests of the current `describe` block or test file.
+ *
+ * They are `before` and `after` of `node:test`, and `beforeAll` and `afterAll` of `bun:test` and Vitest.
+ */
+interface TestHooks {
+  before(hook: () => Promise<void>): unknown;
+  after(hook: () => Promise<void>): unknown;
+}
+/** Options of `testTransaction`. */
+interface TestTransactionOptions {
+  /**
+   * Abort signal of the test, such as `t.signal` of `node:test` or `signal` of the test context of Vitest.
+   *
+   * When it aborts, the test transaction rejects the later queries of the test at once and rolls back without waiting for the test.
+   * It then rejects with the reason of the signal.
+   * If starting or rolling back the transaction fails, it rejects instead with a `SuppressedError` that keeps the reason.
+   * Queries that the test has already sent complete before the rollback.
+   */
+  signal?: AbortSignal;
+}
+/** Test transactions and test fixtures of a database created with `test: true`. */
+interface TestHelpers {
+  /**
+   * Runs `callback` in a transaction that always rolls back.
+   *
+   * Wrap the body of every test in it, so that every run of the test gets its own transaction.
+   * Inside an existing transaction, it starts a nested transaction that always rolls back.
+   */
+  testTransaction<T>(callback: () => Promise<T>, options?: TestTransactionOptions): Promise<T>;
+  /**
+   * Opens a test fixture for the tests of the current `describe` block or test file and runs `seed` in it, such as migrations or data shared by the tests.
+   *
+   * The fixture opens in the `before` hook and rolls back in the `after` hook.
+   * The changes of `seed` stay for the test transactions that run while the fixture is open, and its result is the `data` of the fixture.
+   * Test fixtures nest: a new one opens inside the innermost open one, and test transactions run in the innermost one.
+   * A fixture whose `seed` rejects rolls back and closes.
+   */
+  useTestFixture<T>(seed: () => Promise<T>): TestFixture<T>;
+}
+/** Creates the test helpers of a database created with `test: true`, registering fixtures with the hooks of a test runner. */
+declare function createTestHelpers(database: Database, hooks: TestHooks): TestHelpers;
+/**
+ * Routes statements and scripts to the ambient transaction of the current async context or to the pool.
+ *
+ * This is the only place that decides which connection executes a statement.
+ */
+declare class TransactionCoordinator {
+  #private;
+  readonly driver: Driver;
+  /** Rejects statements and transactions outside a test transaction or the seed of a test fixture instead of running them on the pool. */
+  readonly test: boolean;
+  constructor(driver: Driver,
+  /** Rejects statements and transactions outside a test transaction or the seed of a test fixture instead of running them on the pool. */
+  test?: boolean);
+  execute(statement: SqlStatement): Promise<DriverResult>;
+  /** Executes a script of statements without parameters where `execute` executes a statement. */
+  executeScript(text: string): Promise<void>;
+  /**
+   * Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects.
+   *
+   * Inside a transaction, it runs `callback` in a savepoint nested in it.
+   * A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
+   */
+  transaction<T>(callback: () => Promise<T>): Promise<T>;
+  /**
+   * Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
+   *
+   * Inside a transaction, it runs `callback` in a savepoint nested in it that always rolls back.
+   * When `signal` aborts, the level stops accepting statements at once and ends without waiting for `callback`.
+   * Once the level ends, the transaction rejects with the reason of the signal.
+   * A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
+   * Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
+   */
+  testTransaction<T>(callback: () => Promise<T>, { signal }?: TestTransactionOptions): Promise<T>;
+  /**
+   * Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
+   *
+   * Test transactions started outside any transaction run in the innermost fixture.
+   * A fixture whose `seed` rejects rolls back and closes.
+   */
+  createTestFixture<T>(seed: () => Promise<T>): Promise<OpenedTestFixture<T>>;
+  /**
+   * Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
+   *
+   * Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
+   * Closing an open fixture also closes the fixtures opening in it.
+   */
+  startTestFixture<T>(seed: () => Promise<T>): PendingTestFixture<T>;
+  /**
+   * Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
+   *
+   * A driver waits for every reserved connection, so closing it under an open fixture would wait forever.
+   * A failed closing of the driver suppresses the failures of closing the fixtures.
+   * From the first call, statements, transactions, and fixtures started outside a transaction reject, while the levels already running can still end; a repeated call returns the same closing.
+   */
+  close(): Promise<void>;
+}
+/**
+ * Physical database shared by all schemas bound to it.
+ *
+ * Its ambient transaction spans every schema bound to the same database, such as tenant and SaaS schemas.
+ * Disposing it, such as with `await using`, closes it.
+ */
+interface Database extends AsyncDisposable {
+  /** Routes the statements and transactions of the database; `kern-orm/testing` runs test transactions and test fixtures through it. */
+  readonly coordinator: TransactionCoordinator;
+  /**
+   * Binds a schema to this database, placing its tables in a PostgreSQL schema.
+   *
+   * A database can bind several schemas, which share its connections and transactions.
+   */
+  bind<T extends Tables, R extends SchemaRelations>(schema: Schema<T, R>, options?: BindOptions): Db<T, R>;
+  /**
+   * Starts a query of the SQL statement of the template, as `$query` of a `Db` does, for code without a `Db`.
+   *
+   * It names no tables of a `Db`: run a statement that interpolates them with `$query` of that `Db`.
+   */
+  query(strings: TemplateStringsArray, ...values: unknown[]): SqlQuery<InitialSqlQueryState>;
+  /** Executes a script of statements without parameters, as `$script` of a `Db` does, for code without a `Db`. */
+  script(text: string): Promise<void>;
+  /**
+   * Executes the script of the template, as `$script` of a `Db` does, for code without a `Db`.
+   *
+   * It names no tables of a `Db`: run a script that interpolates them with `$script` of that `Db`.
+   */
+  script(strings: TemplateStringsArray, ...values: unknown[]): Promise<void>;
+  /** Executes a compiled statement, such as of `$compile` of a `Db`, in the ambient transaction, or on the pool outside of one unless the database was created with `test: true`. */
+  execute(statement: SqlStatement): Promise<DriverResult>;
+  /**
+   * Runs `callback` in a transaction that queries of every bound schema join automatically.
+   *
+   * Inside an existing transaction, it starts a nested transaction.
+   */
+  transaction<T>(callback: () => Promise<T>): Promise<T>;
+  /** Rolls back the open test fixtures and closes the connections of the driver once the running transactions end. */
+  close(): Promise<void>;
+}
+/** Options of `createDatabase`. */
+interface DatabaseOptions {
+  driver: Driver;
+  /** Rejects queries and transactions outside the test transactions and the seeds of test fixtures of `kern-orm/testing`, so that every statement of the tests runs in a transaction that rolls back. */
+  test?: boolean;
+}
+/** Creates a database over a driver; its transactions are shared by every schema bound to it. */
+declare function createDatabase({ driver, test }: DatabaseOptions): Database;
+/** Physical placement of the tables of a schema bound to a database. */
+interface BindOptions {
+  /** PostgreSQL schema of the tables; a function is called on every query, such as to resolve the current tenant. */
+  schemaName?: string | (() => string);
+}
+/**
+ * Schema bound to a database with `database.bind`.
+ *
+ * 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<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;
+}
+/** State of an insert, update, or delete query that a `Db` can execute: of table `T`, selecting records only of relations `U`. */
+interface DbMutationState<T extends AnyTable, U extends UsedRelation> extends MutationQueryState {
+  readonly table: T;
+  readonly uses: U;
+}
+interface DbMethods<T extends Tables, R extends SchemaRelations> {
+  readonly $schema: Schema<T, R>;
+  /**
+   * Compiles a query over the tables of the schema into SQL text and parameters.
+   *
+   * A query bound to another `Db`, and a query of a relation that the schema does not have, at any depth, are rejected.
+   */
+  $compile<Q extends DbQuery<T, R>>(query: Q): SqlStatement;
+  /**
+   * Executes a query over the tables of the schema.
+   *
+   * A query bound to another `Db`, and a query of a relation that the schema does not have, at any depth, are rejected.
+   */
+  $execute<Q extends DbQuery<T, R>>(query: Q): Promise<QueryResult<Q["types"]>>;
+  /**
+   * Starts a query of one record whose fields are the values of the expressions and the results of the queries of `selection`, selected in one statement when awaited.
+   *
+   * A query of `selection` is unbound or bound to this `Db`, and the value of its field is the result it gives when executed, such as an array of records or one value.
+   */
+  $select<Sel extends Selection>(selection: Sel): RecordQuery<SelectionState<Sel>, "bound">;
+  /**
+   * Starts a query of the SQL statement of the template, which resolves to the number of the rows of its command tag when awaited, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of its rows instead.
+   *
+   * Interpolated values become query parameters, `sql` fragments and expressions stay SQL, and a table of the `Db`, such as `db.form`, becomes its name, qualified by the PostgreSQL schema of the `Db`.
+   */
+  $query(strings: TemplateStringsArray, ...values: unknown[]): SqlQuery<InitialSqlQueryState>;
+  /**
+   * Executes a script of statements without parameters, such as DDL separated by semicolons, in the ambient transaction, or on the pool outside of one, where PostgreSQL runs them in one implicit transaction.
+   *
+   * The script must not start or end transactions, which the database tracks.
+   */
+  $script(text: string): Promise<void>;
+  /**
+   * Executes the script of the template as `$script` of its text does.
+   *
+   * It interpolates tables of the `Db`, such as `db.form`, and `sql` fragments without values; it rejects values, since a script has no parameters.
+   */
+  $script(strings: TemplateStringsArray, ...values: unknown[]): Promise<void>;
+  /**
+   * Runs `callback` in a transaction of the database, shared by every schema bound to it.
+   *
+   * Inside an existing transaction, it starts a nested transaction.
+   */
+  $transaction<Result>(callback: () => Promise<Result>): Promise<Result>;
+}
+/**
+ * `Db` of schema `S`, such as the type of a parameter of code shared by several schemas.
+ *
+ * A `Db` of a schema that includes `S` is a `Db` of `S` too.
+ */
+type DbOf<S extends AnySchema> = Db<S["$tables"], S[typeof schemaRelations]>;
+/** `Db` of any schema. */
+type AnyDb = Db<any, any>;
+/** Occurrence of a table in `FROM`. */
+interface TableSourceNode {
+  readonly kind: "table";
+  readonly table: AnyTable;
+}
+/**
+ * Occurrence of a subquery in `FROM`, whose columns are the projections of its query, referenced by their keys.
+ *
+ * A plain one sees only the sources of enclosing queries; a `LATERAL` one also sees the sources before it in the same `FROM`.
+ */
+interface DerivedSourceNode {
+  readonly kind: "derived";
+  readonly query: SelectNode;
+  readonly lateral: boolean;
+  /**
+   * Occurrence of a table in `FROM` of `query` that the derived source stands for outside it, such as with the rows of a page of the table.
+   *
+   * Outside `query`, a column reference to the occurrence resolves to the projection of `query` under the key of the column.
+   */
+  readonly replaces?: TableSourceNode;
+}
+/**
+ * One occurrence of a source in `FROM`.
+ *
+ * Column references point to a source by object identity, so two occurrences of the same table never get confused.
+ * The compiler assigns SQL aliases to sources.
+ */
+type SourceNode = TableSourceNode | DerivedSourceNode;
+interface ColumnRefNode {
+  readonly kind: "column";
+  readonly source: SourceNode;
+  /** Key of a column of a table, or of a projection of a derived source. */
+  readonly key: string;
+}
+/** Value bound as a query parameter and numbered only when the complete statement is compiled. */
+interface ParamNode {
+  readonly kind: "param";
+  readonly value: unknown;
+  readonly type: AnyType | undefined;
+}
+/** Cast of an expression to the `castType` of a type. */
+interface CastNode {
+  readonly kind: "cast";
+  readonly operand: ExpressionNode;
+  readonly type: AnyType;
+}
+interface BooleanNode {
+  readonly kind: "boolean";
+  readonly value: boolean;
+}
+interface AndNode {
+  readonly kind: "and";
+  readonly operands: readonly ExpressionNode[];
+}
+interface OrNode {
+  readonly kind: "or";
+  readonly operands: readonly ExpressionNode[];
+}
+interface NotNode {
+  readonly kind: "not";
+  readonly operand: ExpressionNode;
+}
+/** Equality conditions by column key, resolved against the query source by `where` before compilation. */
+interface ValuesNode {
+  readonly kind: "values";
+  readonly values: Readonly<Record<string, unknown>>;
+}
+interface ComparisonNode {
+  readonly kind: "comparison";
+  readonly operator: "=" | "<>" | "<" | "<=" | ">" | ">=" | "LIKE" | "ILIKE";
+  readonly left: ExpressionNode;
+  readonly right: ExpressionNode;
+}
+interface InNode {
+  readonly kind: "in";
+  readonly operand: ExpressionNode;
+  /** Never empty: an empty list is represented as a `FALSE` boolean node. */
+  readonly list: readonly ExpressionNode[];
+}
+interface IsNullNode {
+  readonly kind: "isNull";
+  readonly operand: ExpressionNode;
+}
+/** SQL fragment whose interpolations stay structured nodes until compilation. */
+interface RawSqlNode {
+  readonly kind: "raw";
+  /** Text around interpolations; always one element longer than `values`. */
+  readonly fragments: readonly string[];
+  readonly values: readonly ExpressionNode[];
+}
+/** Name of a table interpolated into a SQL fragment, qualified by the PostgreSQL schema of the statement. */
+interface TableNameNode {
+  readonly kind: "tableName";
+  readonly table: AnyTable;
+  /** `Db` that the interpolated query of the table is bound to, which must be the `Db` that runs the statement. */
+  readonly db: AnyDb | undefined;
+}
+/** Scalar subquery: the value of the only projection of its query, which must return at most one row. */
+interface SubqueryNode {
+  readonly kind: "subquery";
+  readonly query: SelectNode;
+}
+interface ExistsNode {
+  readonly kind: "exists";
+  readonly query: SelectNode;
+}
+/** Call of an aggregate function over the rows of its query, with the order of its input rows. */
+interface AggregateNode {
+  readonly kind: "aggregate";
+  /** Name of the function, such as `json_agg`. */
+  readonly name: string;
+  /** Whether the function takes each distinct value of its arguments once, as `count(DISTINCT ...)`. */
+  readonly distinct: boolean;
+  readonly arguments: readonly ExpressionNode[];
+  readonly orderBy: readonly OrderNode[];
+}
+type ExpressionNode = ColumnRefNode | ParamNode | CastNode | BooleanNode | AndNode | OrNode | NotNode | ValuesNode | ComparisonNode | InNode | IsNullNode | RawSqlNode | TableNameNode | SubqueryNode | ExistsNode | AggregateNode;
+/**
+ * Filters of a query, kept apart so that composing one kind never changes the others.
+ *
+ * The effective predicate is `relation AND scope AND user`.
+ * In particular, a user `OR` cannot bypass a relation condition.
+ */
+interface QueryFilters {
+  /** Correlation with the parent query of a relation. */
+  readonly relation?: ExpressionNode;
+  /** Mandatory restrictions such as soft delete. */
+  readonly scope?: ExpressionNode;
+  /** Conditions added with `where`. */
+  readonly user?: ExpressionNode;
+}
+/**
+ * Expression selected under the key of a result field.
+ *
+ * The key names only the field of the result record: it never shadows a column of a source.
+ */
+type ProjectionNode = ResultField & {
+  readonly expression: ExpressionNode;
+};
+/** Source joined with `LEFT JOIN` to the sources before it; its `ON` condition sees them and the joined source. */
+interface JoinNode {
+  readonly type: "left";
+  readonly source: SourceNode;
+  readonly on: ExpressionNode;
+}
+/** Sort key of `ORDER BY`; `nulls` overrides the placement of `NULL` that PostgreSQL derives from the direction. */
+interface OrderNode {
+  readonly expression: ExpressionNode;
+  readonly direction: "asc" | "desc";
+  readonly nulls: "first" | "last" | 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";
+  /** Source of `FROM`; a query without it has no joins. */
+  readonly from: From;
+  readonly joins: readonly JoinNode[];
+  /** 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;
+  readonly orderBy: readonly OrderNode[];
+  readonly limit: ExpressionNode | undefined;
+  readonly offset: ExpressionNode | undefined;
+  /** Required relation that guarantees the row of the query, such as `field.form`; see `ResultPlan`. */
+  readonly guaranteedBy: string | undefined;
+}
+/** Assignment of `SET` of an update: the value of the column under `key`. */
+interface AssignmentNode {
+  readonly key: string;
+  readonly value: ExpressionNode;
+}
+/**
+ * Parts of a mutation statement of the table occurrence `target`, which its expressions refer to, and the result mode of the rows it changes.
+ *
+ * `returning` holds the fields of `RETURNING` of type `Field`, nested queries of a semantic mutation before lowering, or `undefined` for a statement that returns the number of the rows it changes.
+ */
+interface MutationParts<Field> extends ResultMode {
+  readonly target: TableSourceNode;
+  readonly returning: readonly Field[] | undefined;
+}
+/** Insert statement of rows of `VALUES`. */
+interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
+  readonly kind: "insert";
+  /** Keys of the columns of `VALUES`; none for a row of the defaults of every column. */
+  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)[])[];
+}
+/** Update statement of the rows that its filters choose. */
+interface UpdateNode<Field = ProjectionNode> extends MutationParts<Field> {
+  readonly kind: "update";
+  /** Assignments of `SET`, at least one, with unique keys. */
+  readonly set: readonly AssignmentNode[];
+  readonly filters: QueryFilters;
+}
+/** Delete statement of the rows that its filters choose. */
+interface DeleteNode<Field = ProjectionNode> extends MutationParts<Field> {
+  readonly kind: "delete";
+  readonly filters: QueryFilters;
+}
+/** Statement that inserts, updates, or deletes rows, with the fields of `RETURNING` of type `Field`. */
+type MutationStatementNode<Field = ProjectionNode> = InsertNode<Field> | UpdateNode<Field> | DeleteNode<Field>;
+/**
+ * Statement of SQL text written by a user, such as of `$query`.
+ *
+ * Its result mode is the rows mode of the rows that the statement returns and whether a row is the value of its only column.
+ */
+interface TextStatementNode extends ResultMode {
+  readonly kind: "text";
+  readonly sql: RawSqlNode;
+  /** Fields decoded from the result columns of their keys, or from the only column for a value; `undefined` for a statement that resolves to the number of the rows of its command tag. */
+  readonly fields: readonly ScalarField[] | undefined;
+}
+declare const valueType: unique symbol;
+declare const inputType: unique symbol;
+declare const typed: unique symbol;
+/** Expression of TypeScript type `T` accepting compared values of type `I`, whatever its operators. */
+interface AnyExpression<T = unknown, I = unknown> {
+  readonly [valueType]: T;
+  readonly [inputType]: I;
+}
+/** Expression of values `T` accepting compared values `I`, with `isNull` and operators `O`, whether or not it has a type. */
+type ExpressionWithOperators<T, O extends OperatorDefinitions, I> = AnyExpression<T, I> & Omit<BaseOperators, keyof O> & BoundOperators<O, T, I>;
+/**
+ * Expression with a type, evaluating to a SQL value of TypeScript type `T`.
+ *
+ * Compared plain values are of type `I`, which differs from `T` when the type of the expression accepts other values than it returns, such as a `Date` for `timestamptz`.
+ * It has `isNull` and the operators `O` of its type, which also decodes its values, so it can be selected.
+ * The AST node behind it is internal.
+ */
+type Expression<T = unknown, O extends OperatorDefinitions = EqualityOperators, I = T> = ExpressionWithOperators<T, O, I> & TypedExpression<T>;
+/**
+ * Expression of TypeScript type `T` without a type, such as a fragment of `sql<T>`, with the operators of `equalityOperators`.
+ *
+ * Nothing decodes its values to `T`, so it cannot be selected.
+ */
+type UntypedExpression<T = unknown> = ExpressionWithOperators<T, EqualityOperators, NoInfer<T>>;
+/** Expression that has a type to decode its values, which `select`, `get`, and `pluck` require. */
+type TypedExpression<T = unknown> = AnyExpression<T> & {
+  readonly [typed]: true;
+};
+/** Operators of expressions of every type. */
+interface BaseOperators {
+  isNull(): Expression<boolean>;
+}
+export { one as $, TextValue as $n, and as $t, SqlQueryState as A, ColumnOperators as An, UpdateValues as At, RelationDeclaration as B, NotFoundError as Bn, orderBy as Bt, AnyQuery as C, Operand as Cn, ResultOf as Ct, FieldTypes as D, AnyTable as Dn, ColumnValue as Dt, DecodedFields as E, CompileOptions as En, from as Et, DeclaredRelations as F, Table as Fn, OrderTerms as Ft, RequiredMember as G, Connection as Gn, WhereCondition as Gt, RelationKey as H, ResultDecodeError as Hn, NotAKey as Ht, MergeRelations as I, TableKeys as In, Ordering as It, TableContext as J, SqlStatement as Jn, defineFilter as Jt, SchemaContext as K, Driver as Kn, WhereFilter as Kt, NoRelations as L, TableOptions as Ln, SelectedRefs as Lt, InitialMutationState as M, ColumnValues as Mn, OrderDirection as Mt, MutationQuery as N, KeyColumns as Nn, OrderKey as Nt, InitialSqlQueryState as O, AnyTableKeys as On, InsertValues as Ot, MutationQueryState as P, Selectable as Pn, OrderTerm as Pt, many as Q, BaseType as Qn, Predicate as Qt, OneRelationKeys as R, ToColumns as Rn, asc as Rt, createTestHelpers as S, ComparisonSignature as Sn, FilteredStateRows as St, AnySqlQuery as T, compare as Tn, TableOrQuery as Tt, RelationKeys as U, ResultMode as Un, PrimaryKeyValues as Ut, RelationDeclarations as V, RequiredRelationError as Vn, KeyCheck as Vt, RelationKind as W, ResultRows as Wn, EqValue as Wt, UsableRelation as X, createStatement as Xn, Condition as Xt, TableRelations as Y, TransactionFailure as Yn, CombinedCondition as Yt, UsedRelation as Z, AnyType as Zn, ConditionOperand as Zt, PendingTestFixture as _, EqualityOperators as _n, GenericOperatorImplementation as _r, SelectionResult as _t, UntypedExpression as a, FilteredRows as an, TypeTransform as ar, Tables as at, TestHooks as b, equalityOperators as bn, BoundSelectQuery as bt, Db as c, QueryResult as cn, Column as cr, RecordQuery as ct, DbQueryState as d, EmptyRecord as dn, ToColumn as dr, ExpressionInput as dt, not as en, Type as er, AnySchema as et, Database as f, InitialQueryState as fn, BoundOperators as fr, ExpressionValue as ft, OpenedTestFixture as g, EqualityOperator as gn, GenericOperator as gr, Selection as gt, TransactionCoordinator as h, SelectQueryState as hn, OperatorDefinitions as hr, NestedQuery as ht, TypedExpression as i, RelationRefs as in, TypeOutput as ir, SchemaTables as it, AnyMutationQuery as j, ColumnShape as jn, OrderColumns as jt, SqlQuery as k, ColumnDefinitions as kn, UpdateSet as kt, DbMutationState as l, ResultByRows as ln, ColumnAttributes as lr, RecordQueryState as lt, createDatabase as m, QueryStateOf as mn, NoOperators as mr, MergeSelection as mt, BaseOperators as n, ColumnRefs as nn, TypeOperators as nr, SchemaPart as nt, AnyDb as o, OneRow as on, defineType as or, defineSchema as ot, DatabaseOptions as p, QueryState as pn, MergeOperators as pr, HelperFields as pt, SchemaRelations as q, DriverResult as qn, WhereValues as qt, Expression as r, QueryContext as rn, TypeOptions as rr, SchemaPartRelations as rt, BindOptions as s, OneValueRows as sn, AnyColumn as sr, AnyRecordQuery as st, AnyExpression as t, or as tn, TypeInput as tr, Schema as tt, DbOf as u, ValueRows as un, KeyKind as ur, SelectionState as ut, TestFixture as v, HasEquality as vn, OperatorSignature as vr, SelectionUses as vt, SelectQueryKind as w, OperandValue as wn, SelectQuery as wt, TestTransactionOptions as x, BooleanResult as xn, ChangeState as xt, TestHelpers as y, InSignature as yn, defineGenericOperator as yr, AnySelectQuery as yt, Relation as z, defineTable as zn, desc as zt };