kern-orm 0.6.0 → 0.8.0

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

@@ -49,7 +49,7 @@ type BoundOperators<O extends OperatorDefinitions, T, I = T> = { [K in keyof O]:
 /** Kind of a key of a table: its primary key, or a unique key. */
 type KeyKind = "primaryKey" | "unique";
 /**
- * Type that `primaryKey()` of a type or a column whose values may be `null` is checked against, naming the reason.
+ * Type that `primaryKey()` of a type or a column that accepts `null` is checked against, naming the reason.
  *
  * Without `strictNullChecks`, `null` belongs to every type, so every column looks nullable; the type then names the option instead.
  */
@@ -86,7 +86,7 @@ declare class Column<T extends AnyType, Key extends KeyKind | undefined = KeyKin
   /** Uses a physical column name different from the column key. */
   columnName(name: string): Column<T, Key, Default>;
   /** Marks the column as the primary key; the type must not be nullable. */
-  primaryKey(this: null extends TypeOutput<T> ? NullablePrimaryKey : Column<T, undefined, Default>): Column<T, "primaryKey", Default>;
+  primaryKey(this: null extends TypeInput<T> ? NullablePrimaryKey : Column<T, undefined, Default>): Column<T, "primaryKey", Default>;
   /** Marks the column as a unique key. */
   unique(this: Column<T, undefined, Default>): Column<T, "unique", Default>;
   /** Marks the column as one that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
@@ -148,19 +148,26 @@ interface BaseType<Output, Input, Operators extends OperatorDefinitions, Paramet
   withParameters<P extends unknown[]>(format: (...parameters: P) => string): Type<Output, Input, Operators, P>;
   /**
    * Creates a type with another representation of the values of this type, keeping its SQL type, operators, and nullability.
+   * An `encode` that takes `null` also makes the result nullable.
    *
    * `decode` receives the values that this type decodes from values other than `NULL`, including `undefined` that an earlier decoder returns, and returns a value other than `null`; `encode` returns values that this type encodes; `NULL` stays `null` without them.
    */
-  transform<NewOutput extends {} | undefined, NewInput>(options: TypeTransform<Exclude<Output, null>, NonNullable<Input>, NewOutput, NewInput>): Type<NewOutput | Extract<Output, null>, NewInput | Extract<Input, null>, Operators, Parameters>;
+  transform<NewOutput extends {} | undefined, NewInput>(options: TypeTransform<Exclude<Output, null>, NonNullable<Input>, NewOutput, NewInput>): Type<NewOutput | AcceptedNull<NewInput | Input>, NewInput | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a type that decodes the values of this type into another representation, other than `null`, and accepts the values that this type accepts. */
   transform<NewOutput extends {} | undefined>(options: {
     decode: (value: Exclude<Output, null>) => NewOutput;
-  }): Type<NewOutput | Extract<Output, null>, Input, Operators, Parameters>;
+  }): Type<NewOutput | AcceptedNull<Input>, Input, Operators, Parameters>;
   nullable(): Type<Output | null, Input | null, Operators, Parameters>;
+  /**
+   * Narrows the values of this type to `T` in TypeScript, such as to a union of strings that a `CHECK` constraint allows, or to the shape of JSON values.
+   *
+   * The values are not validated at runtime. `T` must be among the values that this type both returns and accepts, and `nullable` keeps `null` apart from it.
+   */
+  of<T extends AcceptedValues<Exclude<Output, null>, Exclude<Input, null>>>(): Type<T | AcceptedNull<Input>, T | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a column of this type with a physical name different from the column key. */
   columnName(name: string): Column<Type<Output, Input, Operators, Parameters>, undefined, false>;
   /** Creates a primary key column of this type; the type must not be nullable. */
-  primaryKey(this: null extends Output ? NullablePrimaryKey : Type<Output, Input, Operators, Parameters>): Column<Type<Output, Input, Operators, Parameters>, "primaryKey", false>;
+  primaryKey(this: null extends Input ? NullablePrimaryKey : Type<Output, Input, Operators, Parameters>): Column<Type<Output, Input, Operators, Parameters>, "primaryKey", false>;
   /** Creates a column of this type that is a unique key. */
   unique(): Column<Type<Output, Input, Operators, Parameters>, "unique", false>;
   /** Creates a column of this type that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
@@ -171,6 +178,18 @@ interface TypeWithParameters<Output, Input, Operators extends OperatorDefinition
   /** Creates this type with PostgreSQL type parameters, such as `varchar.with(255)` for `varchar(255)`; other changes of the type are kept. */
   with(...parameters: Parameters): Type<Output, Input, Operators, Parameters>;
 }
+/**
+ * Values that `of` can narrow a type to: those both among the values `O` that it returns and among the values `I` that it accepts, or `UnacceptedValues` when there are none.
+ *
+ * A narrowed value is also accepted, so its encoder must take it.
+ */
+type AcceptedValues<O, I> = [O] extends [I] ? O : [I] extends [O] ? I : [O & I] extends [never] ? UnacceptedValues : O & I;
+/** `null` when the accepted values `I` include it, also as `unknown`; `never` otherwise. */
+type AcceptedNull<I> = null extends I ? null : never;
+/** Type that `AcceptedValues` names for a type that accepts none of the values it returns. */
+interface UnacceptedValues {
+  readonly "of narrows only a type that accepts the values it returns": never;
+}
 /** Conversion between the values of a type and their new representation. */
 interface TypeTransform<Output, Input, NewOutput, NewInput> {
   decode: (value: Output) => NewOutput;
@@ -222,15 +241,22 @@ interface DriverResult {
  * 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.
+ * It rejects with `QueryError` a statement or script that PostgreSQL rejected, whose connection stays usable, and with `ConnectionError` any other failure of a statement, a script, or a connection.
  */
 interface Driver {
+  /** Whether the driver closes a reserved connection that it cannot return to the pool, such as one left in a transaction or lost; a driver over a client that cannot close one, such as postgres.js 3, keeps it reserved instead. */
+  readonly closesReservedConnections: boolean;
   /** 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. */
+  /**
+   * Closes the connections once the statements on the pool and the transactions on reserved connections end.
+   *
+   * From the call, it rejects a new statement or script on the pool and a new connection with `ConnectionError`.
+   */
   close(): Promise<void>;
 }
 /** Connection reserved by a driver, such as for a transaction. */
@@ -244,14 +270,14 @@ interface Connection {
   /** 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.
+   * Returns the connection to the pool.
    *
-   * 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.
+   * Without `failure`, the connection is idle: no transaction ran on it, or its `COMMIT` or `ROLLBACK` completed.
+   * With `failure`, the last statement on the connection failed, such as `BEGIN`, `COMMIT`, or `ROLLBACK`, so the connection may be in a transaction or lost: the driver returns it 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. */
+/** Failure of the last statement on a reserved connection, after which the connection may not be idle. */
 interface TransactionFailure {
   readonly error: unknown;
 }
@@ -385,21 +411,23 @@ interface TableKeys<PrimaryKey extends KeyColumns | undefined, UniqueKey extends
   readonly [keysType]: (primaryKey: PrimaryKey, unique: UniqueKey) => readonly [PrimaryKey, UniqueKey];
 }
 /**
- * Immutable table descriptor: physical name, columns, and keys.
+ * Immutable table descriptor: physical name, columns, keys, and whether it holds at most one row.
  *
  * A table knows nothing about relations, schemas, or database connections, so the same table can belong to several schemas.
  * Its object identity is the logical identity of the table.
  */
-interface Table<Name extends string = string, Columns extends ColumnShape = ColumnShape, Keys extends AnyTableKeys = AnyTableKeys> {
+interface Table<Name extends string = string, Columns extends ColumnShape = ColumnShape, Keys extends AnyTableKeys = AnyTableKeys, Singleton extends boolean = boolean> {
   readonly kind: "table";
   readonly name: Name;
   readonly columns: Columns;
   readonly keys: Keys;
+  /** Whether the table holds at most one row, as the `singleton` option of `defineTable` declares; `boolean` where the type of the table does not tell it. */
+  readonly singleton: Singleton;
 }
 /** Table of any name, columns, and keys. */
 type AnyTable = Table<string, ColumnShape>;
 /**
- * Options of `defineTable` over column keys `Column`: the keys of several columns, whose columns are listed in their order.
+ * Options of `defineTable` over column keys `Column`: the keys of several columns, whose columns are listed in their order, and whether the table holds at most one row.
  *
  * The columns of the primary key are of `PrimaryKeyColumn`.
  */
@@ -408,6 +436,12 @@ interface TableOptions<Column extends string = string, PrimaryKeyColumn extends
   readonly primaryKey?: readonly [PrimaryKeyColumn, PrimaryKeyColumn, ...PrimaryKeyColumn[]];
   /** Unique keys of several columns; mark a unique key of one column with `unique()`. */
   readonly unique?: readonly (readonly [Column, Column, ...Column[]])[];
+  /**
+   * Whether the table holds at most one row, such as the settings of an application, which a unique index of `(true)` must guarantee.
+   *
+   * A query of the table starts as a query of that row, which resolves to `undefined` without it, and `upsert` inserts or updates it.
+   */
+  readonly singleton?: boolean;
 }
 /** Options of `createTableFactory`. */
 interface TableFactoryOptions {
@@ -439,8 +473,8 @@ type MatchingKey$1<Key, Columns> = Key extends KeyColumns ? [Key[number]] extend
 type IncludedKey<Key, Columns> = Key extends KeyColumns ? [Key[number]] extends [Columns] ? true : never : never;
 /** Column key of columns `C` as a string, as object keys are at runtime. */
 type ColumnKey<C extends ColumnShape> = `${keyof C & (string | number)}`;
-/** Column key of columns `C` whose type is not nullable, as a string like `ColumnKey`. */
-type NonNullableColumnKey<C extends ColumnShape> = { [K in keyof C]: null extends TypeOutput<C[K]["type"]> ? never : `${K & (string | number)}`; }[keyof C];
+/** Column key of columns `C` whose type does not accept `null`, as a string like `ColumnKey`. */
+type NonNullableColumnKey<C extends ColumnShape> = { [K in keyof C]: null extends TypeInput<C[K]["type"]> ? never : `${K & (string | number)}`; }[keyof C];
 /** Column key of columns `C`, as a string like `ColumnKey`, whose column forms a key of kind `Kind` alone, as `KnownKeyKind` tells. */
 type KeyedColumn<C extends ColumnShape, Kind> = { [K in keyof C]: KnownKeyKind<C[K]["attributes"]["keyKind"]> extends Kind ? `${K & (string | number)}` : never; }[keyof C];
 /** Kind `Kind` of the key that a column forms alone, or `"unknown"` where the type of the column does not tell it. */
@@ -462,6 +496,8 @@ type KnownKeysOf<PrimaryKey extends KeyColumns | undefined, UniqueKey extends Ke
 type DefinedPrimaryKey<C extends ColumnShape, PrimaryKey> = PrimaryKey extends KeyColumns ? PrimaryKey : [KeyedColumn<C, "primaryKey">] extends [never] ? undefined : SingleColumnKey<KeyedColumn<C, "primaryKey">>;
 /** Unique key of a table of columns `C`: `UniqueKey` of its options, or of a column marked with `unique()`. */
 type DefinedUniqueKey<C extends ColumnShape, UniqueKey> = Extract<UniqueKey, KeyColumns> | SingleColumnKey<KeyedColumn<C, "unique">>;
+/** Whether a table of options `O` holds at most one row: `true` or `false` of their `singleton`, `false` without it, or `boolean` where its type does not tell it. */
+type DefinedSingleton<O> = O extends unknown ? [O["singleton" & keyof O]] extends [false | undefined] ? false : [O["singleton" & keyof O]] extends [true] ? true : boolean : never;
 /** Key of each single column of `K`. */
 type SingleColumnKey<K> = K extends string ? readonly [K] : never;
 /** Primary key in options `O`: `undefined` without one, or `"unknown"` where its type does not tell it. */
@@ -479,13 +515,13 @@ type IsExactKey<K> = true extends IsUnion<K> ? false : K extends readonly unknow
  *
  * A key of one column is marked on its column.
  */
-declare function defineTable<Name extends string, Definitions extends ColumnDefinitions>(name: Name, definitions: Definitions): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, undefined>>;
+declare function defineTable<Name extends string, Definitions extends ColumnDefinitions>(name: Name, definitions: Definitions): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, undefined>, false>;
 /**
  * Defines a table; a type without column attributes becomes a column as it is.
  *
- * A key of one column is marked on its column, and `options` list the columns of the keys of several columns.
+ * A key of one column is marked on its column, and `options` list the columns of the keys of several columns and tell whether the table holds at most one row.
  */
-declare function 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>>;
+declare function defineTable<Name extends string, Definitions extends ColumnDefinitions, const Options extends TableOptions<ColumnKey<ToColumns<Definitions>>, PrimaryKeyOption<ToColumns<Definitions>>> | undefined>(name: Name, definitions: Definitions, options: Options): Table<Name, ToColumns<Definitions>, DefinedKeys<ToColumns<Definitions>, Options>, DefinedSingleton<Options>>;
 /**
  * Creates a table-definition function with the given naming convention, for an application to define its tables with.
  *
@@ -556,6 +592,23 @@ interface InitialQueryState<T extends AnyTable, C extends SchemaContext = NoRela
   readonly guaranteed: Guaranteed;
   readonly aggregate: false;
 }
+/**
+ * State of a query that starts from table `T` with schema context `C`, as the entry points of a schema and a `Db` and `from` start it: of all the rows of the table, or of the one row of a singleton table.
+ *
+ * Where the type of `T` does not tell whether it is a singleton, such as `Table<Name, Columns>`, it is the union of both.
+ */
+type TableQueryState<T extends AnyTable, C extends SchemaContext = NoRelations> = SingletonOrInitialState<T, C, T["singleton"]>;
+/** State of a query that starts from table `T` with schema context `C`, as `TableQueryState` gives it, by `Singleton`, the `singleton` of the type of `T`. */
+type SingletonOrInitialState<T extends AnyTable, C extends SchemaContext, Singleton> = Singleton extends true ? SingletonQueryState<T, C> : InitialQueryState<T, C>;
+/** State of a query that starts from singleton table `T` with schema context `C`: its one row as a record without fields, which resolves to `undefined` without it. */
+interface SingletonQueryState<T extends AnyTable, C extends SchemaContext = NoRelations> extends InitialQueryState<T, C, never, "optional">, FoundKey<never> {}
+/** Key of the member of `FoundKey` that makes it invariant in the columns of the key. */
+declare const foundKeyVariance: unique symbol;
+/** Part of the state of a query of `find` or `findBy` with the columns `K` of its key, or of a query of a singleton table without them, which `upsert` applies to. */
+interface FoundKey<K extends string> {
+  readonly foundKey: K;
+  readonly [foundKeyVariance]: { readonly [C in K]: true; };
+}
 /** Mark of `aggregate: false` of a query of groups, which aggregate methods replace. */
 interface Grouped {
   readonly grouped: true;
@@ -705,6 +758,12 @@ interface QueryNode extends ResultMode {
   readonly all: boolean;
   /** How `map` and `transform` convert the decoded result. */
   readonly conversion: ResultConversion | undefined;
+  /**
+   * Values of the columns of the key of `find` or `findBy` of a query of a table without clauses, which `upsert` inserts, an empty object for a query that starts from a singleton table, whose key has no columns, or `undefined` for any other query.
+   *
+   * Every method that derives a node from the query drops them, whereas `use` returns the query of its callback, such as the query itself.
+   */
+  readonly foundKey: Readonly<Record<string, unknown>> | undefined;
 }
 /**
  * Mutation of a table that returns the fields of the rows it changes, which may nest queries, or the number of the rows without them.
@@ -816,13 +875,15 @@ type QueryWhereFilter<S extends SelectQueryState> = [S] extends [unknown] ? Wher
  * 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;
+/** Columns of the primary key of table `T`, or `never` where the type of `T` tells no primary key. */
+type PrimaryKeyColumn<T extends AnyTable> = T extends AnyTable ? T["keys"] extends TableKeys<infer PrimaryKey extends KeyColumns, infer _UniqueKey> ? PrimaryKey[number] : never : never;
 /**
- * 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.
+ * Check of columns `Columns`, of the object of `findBy` or of `onConflict`, that rejects them unless they are exactly a key of table `T`, primary or unique, as the type of `T` tells.
  *
  * 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. */
+/** Type that the columns of `findBy` and `onConflict` are checked against when they are not exactly a key of the table, naming the keys of the table. */
 interface NotAKey<Keys> {
   readonly "columns must be exactly one key of the table": Keys;
 }
@@ -869,11 +930,23 @@ 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;
-}>;
+/** State `S` after a filter followed by `take`, as `find` and `findBy` change it, with the columns `K` of their key for `upsert`. */
+interface FoundState<S extends SelectQueryState, K extends string> extends SelectQueryState, FoundKey<K> {
+  readonly table: S["table"];
+  readonly schema: S["schema"];
+  readonly result: S["result"];
+  readonly rows: OneRow<FilteredStateRows<S>>;
+  readonly value: S["value"];
+  readonly valueType: S["valueType"];
+  readonly fieldTypes: S["fieldTypes"];
+  readonly uses: S["uses"];
+  readonly guaranteed: false;
+  readonly aggregate: S["aggregate"];
+}
+/** State of a query of `find` or `findBy`, or of a singleton table, which `upsert` applies to. */
+type FoundQueryState = SelectQueryState & {
+  readonly foundKey: string;
+};
 /** State of a query whose rows are records, which `select` and `clearSelect` change. */
 type RecordQueryState$1 = SelectQueryState & {
   readonly value: false;
@@ -988,10 +1061,14 @@ type ColumnValue<T extends AnyTable, K extends keyof T["columns"]> = ColumnValue
 type OptionalColumnKey<T extends AnyTable> = { [K in keyof T["columns"]]: T["columns"][K]["attributes"]["hasDefault"] extends true ? K : null extends ColumnValues<T>[K] ? K : never; }[keyof T["columns"]];
 /** Record of an insert into table `T`: the values of its columns, which may omit a column with a default or a nullable column, or give it as `undefined`. */
 type InsertValues<T extends AnyTable> = { readonly [K in keyof T["columns"] as K extends OptionalColumnKey<T> ? never : K]: ColumnValue<T, K>; } & { readonly [K in OptionalColumnKey<T>]?: ColumnValue<T, K> | undefined; };
+/** Values of `upsert` into table `T`: a record of an insert without the columns `K` of the key, whose values `find` or `findBy` gives. */
+type UpsertValues<T extends AnyTable, K extends string> = { readonly [C in keyof T["columns"] as C extends OptionalColumnKey<T> | K ? never : C]: ColumnValue<T, C>; } & { readonly [C in Exclude<OptionalColumnKey<T>, K>]?: ColumnValue<T, C> | undefined; };
 /** Values of the columns of table `T` that an update sets; a column omitted or given as `undefined` keeps its value. */
 type UpdateValues<T extends AnyTable> = { readonly [K in keyof T["columns"]]?: ColumnValue<T, K> | undefined; };
 /** Argument of `update` of table `T` with schema context `C`: the values that it sets, or a callback that receives the columns and the queries of the relations of the changed rows and returns them. */
 type UpdateSet<T extends AnyTable, C extends SchemaContext = NoRelations> = UpdateValues<T> | ((columns: ColumnRefs<T> & RelationRefs<C>) => UpdateValues<T>);
+/** Argument of `update` of a conflict of an insert into table `T` with schema context `C`: the values that it sets on the existing record, or a callback that receives the columns and the queries of the relations of the existing record and the columns of the row proposed for insertion, and returns them. */
+type ConflictUpdateSet<T extends AnyTable, C extends SchemaContext = NoRelations> = UpdateValues<T> | ((columns: ColumnRefs<T> & RelationRefs<C>, excluded: ColumnRefs<T>) => UpdateValues<T>);
 /** State `S` with the parts of `Changes` replaced. */
 type ChangeState<S extends SelectQueryState, Changes extends Partial<SelectQueryState>> = { readonly [K in keyof SelectQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
 /** Query of state `S`, bound or unbound. */
@@ -1067,15 +1144,17 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    *
    * A value is what `where` takes for its column, such as an expression, but never `null` or `undefined`.
    * Without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
+   * To insert the record of the key or update the existing one, call `upsert` right after it.
    */
-  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S>, Kind>;
+  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S, PrimaryKeyColumn<S["table"]>>, Kind>;
   /**
    * Filters the query by the values of the columns of one key of the table, primary or unique, and returns the row instead of an array, as `where` followed by `take`, but without a limit.
    *
    * A value is what `where` takes for its column, such as an expression, but never `null` or `undefined`.
    * Without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
+   * To insert the record of the key or update the existing one, call `upsert` right after it.
    */
-  findBy<S extends SelectQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, values: { readonly [C in K]: NonNullable<EqValue<S["table"], C>>; } & KeyCheck<S["table"], K>): SelectQuery<FoundState<S>, Kind>;
+  findBy<S extends SelectQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, values: { readonly [C in K]: NonNullable<EqValue<S["table"], C>>; } & KeyCheck<S["table"], K>): SelectQuery<FoundState<S, K>, Kind>;
   /**
    * Replaces the selected fields with a column, limits the query to one row, and returns the value of the column instead of a record.
    *
@@ -1369,22 +1448,34 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * A column omitted or given as `undefined` gets its default, so only columns marked with `hasDefault` and nullable columns may be omitted.
    * A value is what the type of its column takes, `null` for `NULL`, an expression, such as a `sql` fragment, or a query of one value, which gives `NULL` without its row.
    * Select the fields that it returns after it, such as `insert(values).get("id")`.
+   * To handle a conflict of the record with an existing one on a key, call `onConflict` right after `insert`.
    */
-  insert<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: InsertValues<S["table"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], "one">, Kind>;
+  insert<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: InsertValues<S["table"]>): MutationQuery<InitialInsertState<S["table"], S["schema"], "one">, Kind>;
   /**
    * Inserts records into the table of a query without clauses, such as a table of a `Db`, in one statement, and resolves to the number of the inserted rows.
    *
    * A record takes the values that `insert` takes, and a column that a record omits gets its default.
    * Select the fields that it returns for the inserted rows after it, such as `insertMany(records).select("id", "email")`, and match them to the records by a key rather than by their order, which PostgreSQL does not guarantee.
+   * To handle a conflict of a record with an existing one on a key, call `onConflict` right after `insertMany`.
+   * A singleton table, which holds one row, takes `insert` or `upsert` instead.
+   */
+  insertMany<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, records: readonly InsertValues<S["table"]>[] & InsertManyCheck<S["table"]>): MutationQuery<InitialInsertState<S["table"], S["schema"], "many">, Kind>;
+  /**
+   * Inserts the record of the key of `find` or `findBy` with `values`, or updates `values` of the existing record of the key, in one statement, and resolves to the number of the inserted or updated rows, `1`.
+   *
+   * `values` takes what `insert` takes, apart from the columns of the key, and at least one value other than `undefined`; a column omitted or given as `undefined` gets its default when the record is inserted and keeps its value when the record is updated.
+   * Call it right after `find` or `findBy` of a query of a table without other clauses, such as filters, or on a query of a singleton table without clauses, such as `db.settings.upsert(values)`, to insert or update its row.
+   * Select the fields that it returns after it, such as `upsert(values).get("id")`.
+   * To update the existing record with other values than the inserted ones, such as to increment a counter, call `onConflict` after `insert` instead.
    */
-  insertMany<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, records: readonly InsertValues<S["table"]>[]): MutationQuery<InitialMutationState<S["table"], S["schema"], "many">, Kind>;
+  upsert<S extends FoundQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, values: UpsertValues<S["table"], S["foundKey"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], "one">, Kind>;
   /**
    * Updates the rows that the filters of the query choose with the values that `callback` returns, and resolves to the number of the updated rows.
    *
    * `callback` receives the columns and the queries of the relations of the changed rows, such as to set a column from another one or from related records, and returns the values of the columns to update; a column omitted or given as `undefined` keeps its value.
    * A value is what `insert` takes as a value, such as a query of an aggregate of related records.
    * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
-   * A query without a filter must call `all` to update every row.
+   * A query without a filter must call `all` to update every row, unless it is a query of a singleton table, which updates its row.
    * Select the fields that it returns after it, with their values after the update, such as `update(callback).select("id")`.
    */
   update<S extends SelectQueryState, Kind extends SelectQueryKind, F extends (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => UpdateValues<S["table"]>>(this: SelectQuery<S, Kind>, callback: F): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"], OperandUses<ReturnType<F>[keyof ReturnType<F>]>>, Kind>;
@@ -1394,7 +1485,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * `set` gives the values of the columns to update, or is a callback that returns them; a column omitted or given as `undefined` keeps its value.
    * A value is what `insert` takes as a value.
    * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
-   * A query without a filter must call `all` to update every row.
+   * A query without a filter must call `all` to update every row, unless it is a query of a singleton table, which updates its row.
    * Select the fields that it returns after it, with their values after the update, such as `update(set).select("id")`.
    */
   update<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, set: UpdateSet<S["table"], S["schema"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
@@ -1402,7 +1493,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * Deletes the rows that the filters of the query choose, and resolves to the number of the deleted rows.
    *
    * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
-   * A query without a filter must call `all` to delete every row.
+   * A query without a filter must call `all` to delete every row, unless it is a query of a singleton table, which deletes its row.
    * Select the fields that it returns after it, such as `delete().pluck("id")`.
    */
   delete<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
@@ -1452,7 +1543,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It rejects a query of records, which `ValuesQuery` rejects in types.
    */
   [valuesQueryNode](): NestedQueryNode;
-  /** Creates a query of the same kind and `Db` with the node changes applied. */
+  /** Creates a query of the same kind and `Db` with the node changes applied, dropping the key of `find` and `findBy` unless the changes give it. */
   private derive;
   /**
    * Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
@@ -1472,7 +1563,11 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   private addFilter;
   /** Returns the rows mode of this query after a filter, as `FilteredStateRows` gives it in types. */
   private getFilteredRows;
-  /** Creates the query of `find` and `findBy`: `where` of `values`, an object of column values, returning one row like `take`. */
+  /**
+   * Creates the query of `find` and `findBy`: `where` of `values`, an object of the values of the columns of a key, returning one row like `take`.
+   *
+   * On a query of a table without clauses, it keeps `values` as the key that `upsert` inserts.
+   */
   private takeWhere;
   /** Creates the query of one row with rows mode `rows` that `method` returns, rejecting a query of many rows. */
   private changeOneRow;
@@ -1485,6 +1580,12 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /** Rejects `method`, an aggregate method or `exists`, on a query made by one of them or with a row lock. */
   private rejectAggregation;
 }
+/** Check of the records of `insertMany` into table `T` that rejects them for a singleton table, which holds one row. */
+type InsertManyCheck<T extends AnyTable> = T["singleton"] extends true ? SingletonInsertMany : unknown;
+/** Type that the records of `insertMany` into a singleton table are checked against, naming the reason. */
+interface SingletonInsertMany {
+  readonly "insertMany cannot insert into a singleton table, which holds one row; use insert or upsert": never;
+}
 /** Select query bound to a `Db`, executed by awaiting it; every method returns a query bound to the same `Db`. */
 type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
 /** Select query of any state and kind. */
@@ -1494,7 +1595,11 @@ type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
 /** Table of a definition such as `defineExpression`: the table itself or a query over it with schema context `C`, such as `schema.form`. */
 type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
 /** Starts a query over a new occurrence of the table. */
-declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T>>;
+declare function from<T extends Table<string, ColumnShape, AnyTableKeys, false>>(table: T): SelectQuery<InitialQueryState<T>>;
+/** Starts a query of the one row of a singleton table over a new occurrence of the table. */
+declare function from<T extends Table<string, ColumnShape, AnyTableKeys, true>>(table: T): SelectQuery<SingletonQueryState<T>>;
+/** Starts a query over a new occurrence of a table whose type does not tell whether it is a singleton table, of all its rows or of its one row. */
+declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T> | SingletonQueryState<T>>;
 /** References to the columns of the query source, passed to query callbacks. */
 type ColumnRefs<T extends AnyTable> = { readonly [K in keyof T["columns"]]: Expression<Selectable<T>[K], ColumnOperators<T, K>, ColumnValues<T>[K]>; };
 /**
@@ -1882,6 +1987,16 @@ interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows
   readonly value: true;
   readonly uses: U;
 }
+/** State of an insert of `insert` or `insertMany` of table `T` with schema context `C` in rows mode `Rows`, before any other method. */
+interface InitialInsertState<T extends AnyTable, C extends SchemaContext, Rows extends ResultRows> extends InitialMutationState<T, C, Rows> {
+  readonly insert: true;
+}
+/** State of an insert that no method has changed since `insert` or `insertMany`, which `onConflict` applies to. */
+interface InsertMutationState extends MutationQueryState {
+  readonly insert: true;
+}
+/** Rows mode of the rows that an insert of rows mode `Rows` changes when it skips the rows that conflict: a missing row of an insert of one record. */
+type SkippedRows<Rows extends ResultRows> = Rows extends "one" ? "optional" : Rows;
 /** State `S` of a mutation with the parts of `Changes` replaced. */
 type ChangeMutationState<S extends MutationQueryState, Changes extends Partial<MutationQueryState>> = { readonly [K in keyof MutationQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
 /** State of a mutation that returns the number of the rows it changes or their records, which `select` applies to. */
@@ -2034,6 +2149,12 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
    * A selection of no fields fails as well on a mutation that returns the number of its rows.
    */
   use<S extends HelperMutationInput<T, E>, Kind extends SelectQueryKind, T extends AnyTable, E extends HelperEffect, A extends unknown[]>(this: MutationQuery<S, Kind>, helper: Helper<T, E, A>, ...args: A): E extends HelperEffect ? MutationQuery<HelperMutationState<S, E>, Kind> : never;
+  /**
+   * Chooses the key, primary or unique, of `columns` on which a row of the insert may conflict with an existing record; without columns, `doNothing` skips a row that conflicts on any key, and `merge` and `update` update the row of a singleton table.
+   *
+   * Call it right after `insert` or `insertMany`, choose the action on its result, such as `doNothing()`, and select the fields that the mutation returns after the action.
+   */
+  onConflict<S extends InsertMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string = never>(this: MutationQuery<S, Kind>, ...columns: (K & KeyCheck<S["table"], K>)[]): ConflictTarget<S, Kind, K>;
   /**
    * Compiles the query into SQL text and parameters; `schemaName` qualifies its tables.
    *
@@ -2051,6 +2172,74 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
 }
 /** Query of any state and kind that inserts, updates, or deletes rows. */
 type AnyMutationQuery = MutationQuery<any, SelectQueryKind>;
+/**
+ * Conflict target of an insert of state `S` on the key of columns `K`, or without columns for `never`, with methods that choose the action and return the mutation: without columns, `doNothing` takes any key, and `merge` and `update` the row of a singleton table.
+ *
+ * It is no query: awaiting it is a type error and rejects, so that an insert without an action does not resolve without running.
+ */
+declare class ConflictTarget<out S extends InsertMutationState, out Kind extends SelectQueryKind = "unbound", out K extends string = string> {
+  /** Insert whose rows conflict. */
+  readonly insert: MutationQuery<S, Kind>;
+  /** Columns of the key that the rows conflict on, in its order, or none, as `onConflict` without columns gives them. */
+  readonly target: readonly K[];
+  constructor(
+  /** Insert whose rows conflict. */
+  insert: MutationQuery<S, Kind>,
+  /** Columns of the key that the rows conflict on, in its order, or none, as `onConflict` without columns gives them. */
+  target: readonly K[]);
+  /**
+   * Skips each row that conflicts, as `ON CONFLICT DO NOTHING`, and returns the mutation.
+   *
+   * After `insert`, the mutation resolves to `0` when the row conflicts, and the fields selected after it to `undefined`.
+   * After `insertMany`, it resolves to the number of the inserted rows, and the fields selected after it are those of the inserted rows.
+   */
+  doNothing<S extends InsertMutationState, Kind extends SelectQueryKind>(this: ConflictTarget<S, Kind>): MutationQuery<ChangeMutationState<S, {
+    changed: SkippedRows<S["changed"]>;
+  }>, Kind>;
+  /**
+   * Updates the existing record of each row that conflicts with the values of `columns` of the row, as `DO UPDATE SET column = EXCLUDED.column`, or with every column that the insert gives, apart from the key, without columns, and returns the mutation of the inserted and the updated rows.
+   *
+   * Every record must give each column that it sets.
+   * After `onConflict()` without columns, it updates the row of a singleton table.
+   */
+  merge<S extends InsertMutationState, Kind extends SelectQueryKind, K extends string, C extends Exclude<keyof S["table"]["columns"] & string, K>>(this: ConflictTarget<S, Kind, K> & ConflictKeyCheck<S, K>, ...columns: C[]): MutationQuery<ChangeMutationState<S, {
+    changed: S["changed"];
+  }>, Kind>;
+  /**
+   * Updates the existing record of each row that conflicts with the values that `callback` returns, as `DO UPDATE SET`, and returns the mutation of the inserted and the updated rows.
+   *
+   * `callback` receives the columns and the queries of the relations of the existing record, and the columns of the row proposed for insertion, `excluded`, such as to add its value to the existing one.
+   * After `onConflict()` without columns, it updates the row of a singleton table.
+   */
+  update<S extends InsertMutationState, Kind extends SelectQueryKind, K extends string, F extends (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>, excluded: ColumnRefs<S["table"]>) => UpdateValues<S["table"]>>(this: ConflictTarget<S, Kind, K> & ConflictKeyCheck<S, K>, callback: F): MutationQuery<ChangeMutationState<S, {
+    uses: S["uses"] | OperandUses<ReturnType<F>[keyof ReturnType<F>]>;
+  }>, Kind>;
+  /**
+   * Updates the existing record of each row that conflicts with the values of `set`, as `DO UPDATE SET`, and returns the mutation of the inserted and the updated rows.
+   *
+   * `set` gives the values of the columns to update, or is a callback that returns them from the existing record and the row proposed for insertion, `excluded`.
+   * After `onConflict()` without columns, it updates the row of a singleton table.
+   */
+  update<S extends InsertMutationState, Kind extends SelectQueryKind, K extends string>(this: ConflictTarget<S, Kind, K> & ConflictKeyCheck<S, K>, set: ConflictUpdateSet<S["table"], S["schema"]>): MutationQuery<ChangeMutationState<S, {
+    changed: S["changed"];
+  }>, Kind>;
+  /** Rejects awaiting the conflict target, which needs an action, such as `doNothing()`. */
+  then(_action: ConflictActionRequired): never;
+  /** Returns the node of the insert, which `onConflict` takes only of an insert. */
+  private insertNode;
+  /** Creates the insert of the same kind and `Db` with `conflict`, changing rows `rows`. */
+  private derive;
+}
+/** Type of the parameter of `then` of a conflict target, which makes awaiting the target before an action a type error. */
+interface ConflictActionRequired {
+  readonly "onConflict needs an action, such as doNothing()": never;
+}
+/** Check of the columns `K` of a conflict target of an insert of state `S` that rejects `merge` and `update` of a conflict on any key, which PostgreSQL does not update, unless the table is a singleton table, whose row they update. */
+type ConflictKeyCheck<S extends InsertMutationState, K extends string> = [K] extends [never] ? S["table"]["singleton"] extends true ? unknown : ConflictKeyRequired : unknown;
+/** Type that a conflict target on any key is checked against by `merge` and `update`, naming the reason. */
+interface ConflictKeyRequired {
+  readonly "merge and update need the columns of a key in onConflict": never;
+}
 /** Types of the fields of the rows of a query of SQL text by the names of the result columns they decode. */
 interface FieldTypes {
   readonly [key: string]: AnyType;
@@ -2239,8 +2428,8 @@ type Tables = Record<string, AnyTable>;
  * 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>>>; };
+/** Query entry points; each access starts a query over a new table occurrence, of the one row of a singleton table. */
+type SchemaEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: SelectQuery<TableQueryState<T[K], TableContext<R, K>>>; };
 /** Members of a schema that composition reads: its tables and the relations of its tables. */
 interface SchemaContents<T extends Tables, R extends SchemaRelations> {
   readonly [schemaBrand]: true;
@@ -2693,8 +2882,8 @@ interface BindOptions {
  * Its table entries start queries bound to it, which execute when awaited.
  */
 type Db<T extends Tables, R extends SchemaRelations = EmptyRecord> = DbEntries<T, R> & DbMethods<T, R>;
-/** Bound query entry points; each access starts a query over a new table occurrence. */
-type DbEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: BoundSelectQuery<InitialQueryState<T[K], TableContext<R, K>>>; };
+/** Bound query entry points; each access starts a query over a new table occurrence, of the one row of a singleton table. */
+type DbEntries<T extends Tables, R extends SchemaRelations> = { readonly [K in keyof T]: BoundSelectQuery<TableQueryState<T[K], TableContext<R, K>>>; };
 /** Bound or unbound query over a table of `T`, also converted by `transform`, of `$select`, or that changes the rows of a table of `T`, that selects records only of relations of `R`, or a query of SQL text. */
 type DbQuery<T extends Tables, R extends SchemaRelations> = QueryOf<DbQueryState<T[keyof T], UsableRelation<R>>> | TransformedQuery<TransformedQueryState<T[keyof T], unknown, UsableRelation<R>>, SelectQueryKind> | RecordQuery<RecordQueryState<unknown, UsableRelation<R>>, SelectQueryKind> | MutationQuery<DbMutationState<T[keyof T], UsableRelation<R>>, SelectQueryKind> | SqlQuery<SqlQueryState>;
 /** State of a query that a `Db` can execute: over table `T`, selecting records only of relations `U`. */
@@ -3022,6 +3211,23 @@ interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
   readonly columns: readonly string[];
   /** Rows of `VALUES`, at least one, each with a value of every column in their order, or `undefined` for `DEFAULT`. */
   readonly values: readonly (readonly (ExpressionNode | undefined)[])[];
+  /** `ON CONFLICT` of the insert, or `undefined` for an insert that rejects a row that conflicts on a key. */
+  readonly conflict?: ConflictNode | undefined;
+}
+/** `ON CONFLICT` of an insert: a row that conflicts on `target` updates the existing row by `update`, or is skipped, as `DO NOTHING`, without it. */
+interface ConflictNode {
+  /**
+   * What a row conflicts on: the keys of the columns of a key of the table, in its order, none for any key, which only `DO NOTHING` takes, or `"singleton"` for the unique index of `(true)` of a singleton table, which holds its one row.
+   */
+  readonly target: readonly string[] | "singleton";
+  readonly update?: ConflictUpdateNode | undefined;
+}
+/** `DO UPDATE SET` of `ON CONFLICT`, whose values see the existing row as the target of the insert and the row proposed for insertion as `excluded`. */
+interface ConflictUpdateNode {
+  /** Assignments of `SET`, at least one, with unique keys. */
+  readonly set: readonly AssignmentNode[];
+  /** Occurrence of the table that stands for the row proposed for insertion, `EXCLUDED` of PostgreSQL, which the values of `set` refer to and which is in no `FROM`. */
+  readonly excluded: TableSourceNode;
 }
 /** Update statement of the rows that its filters choose. */
 interface UpdateNode<Field = ProjectionNode> extends MutationParts<Field> {
@@ -3129,6 +3335,61 @@ declare const textOperators: TextOperators;
 declare const TRUE: Expression<boolean>;
 /** Condition that never holds, such as for a branch of `or` built in code: `or(check, isAdmin ? other : FALSE)`. */
 declare const FALSE: Expression<boolean>;
+/**
+ * Error of a statement that PostgreSQL rejected, such as for a violated constraint; the connection of the statement stays usable.
+ *
+ * A driver whose client gives the severity of an error only in the language of the server, such as node-postgres, tells such an error by its SQLSTATE when the server translates its messages.
+ * An error that ends the session with a code that a statement also gets, such as `40001` of a conflict with recovery on a replica, then rejects with `QueryError`, and the next statement on the connection with `ConnectionError`.
+ */
+declare class QueryError extends Error {
+  readonly name = "QueryError";
+  /** SQLSTATE of the error, such as `23505` for a violated unique constraint. */
+  readonly code: string;
+  /** Name of the constraint that the statement violated, if any. */
+  readonly constraint: string | undefined;
+  constructor(message: string, fields: {
+    code: string;
+    constraint?: string | undefined;
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `QueryError` of another copy of kern-orm. */
+  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
+}
+/**
+ * Error of a statement or connection that failed for another reason than PostgreSQL rejecting a statement, such as a lost connection, a timeout of the client, or a closed driver.
+ *
+ * The statement may have run or not, and its connection may be lost or in an unknown state of its transaction.
+ */
+declare class ConnectionError extends Error {
+  readonly name = "ConnectionError";
+  constructor(message: string, options?: {
+    cause?: unknown;
+  });
+  /** Tells whether `value` is an instance of the class, including one of `ConnectionError` of another copy of kern-orm. */
+  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
+}
+/** Fields of the PostgreSQL error that an error of a client carries, by which `toDriverError` classifies it. */
+interface DriverErrorFields {
+  /**
+   * Severity of the error, such as `ERROR` or `FATAL`.
+   *
+   * Pass the severity in English when the client gives it, and the one in the language of the server otherwise.
+   */
+  readonly severity?: unknown;
+  /** SQLSTATE of the error, such as `23505`. */
+  readonly code?: unknown;
+  /** Name of the constraint that the statement violated. */
+  readonly constraint?: unknown;
+}
+/**
+ * Classifies an error of a client as `QueryError` or `ConnectionError`, by the fields of the PostgreSQL error it carries, for a driver to reject with.
+ *
+ * An error that kern-orm has already classified returns as it is.
+ * An error without a severity or a SQLSTATE, such as of a client that lost its connection, is a `ConnectionError`, and so is one of severity `FATAL` or `PANIC`, which ends the session.
+ * An error of severity `ERROR` is a `QueryError`.
+ * With a translated severity, the SQLSTATE tells an error that ends the session, so a few errors of other codes that end it give `QueryError`.
+ */
+declare function toDriverError(error: unknown, fields?: DriverErrorFields): QueryError | ConnectionError;
 /**
  * Defines a reusable expression of a table, which the callbacks of queries over the table call with their columns and any further arguments, such as to filter by it and select it in one query.
  *
@@ -3212,4 +3473,4 @@ declare function param<E extends AnyExpression, V extends (E extends AnyExpressi
  * A run of capital letters is one word, such as `user_id` for `userID`, and digits stay in their word, such as `line2`.
  */
 declare function toSnakeCase(key: string): string;
-export { NoRelations as $, UpdateSet as $n, AnyTableKeys as $r, least as $t, Db as A, TypeOptions as Ai, some as An, CompileOptions as Ar, DecodedFields as At, PendingTestFixture as B, MergeOperators as Bi, asc as Bn, compare as Br, HelperEffect as Bt, BaseOperators as C, createStatement as Ci, UnfilteredStringAggOptions as Cn, FilteredRows as Cr, AnyRecordQuery as Ct, UntypedExpression as D, Type as Di, every as Dn, ResultByRows as Dr, AnyQuery as Dt, TypedExpression as E, TextValue as Ei, countDistinct as En, QueryResult as Er, SelectionState as Et, DatabaseOptions as F, Column as Fi, OrderKey as Fn, equalityOperators as Fr, AnyMutationQuery as Ft, createTestHelpers as G, OperatorSignature as Gi, RelationRefs as Gn, EmptyRecord as Gr, FollowingOperand as Gt, TestHelpers as H, OperatorDefinitions as Hi, orderBy as Hn, ScalarQuery as Hr, CaseBranch as Ht, TransactionOptions as I, ColumnAttributes as Ii, OrderTerm as In, BooleanResult as Ir, InitialMutationState as It, SynchronousResult as J, ResultOf as Jn, QueryState as Jr, TypedOperandInput as Jt, AnyTransformedQuery as K, defineGenericOperator as Ki, AnySelectQuery as Kn, Grouped as Kr, NullSkippingResult as Kt, createDatabase as L, KeyKind as Li, OrderTerms as Ln, ComparisonSignature as Lr, MutationQuery as Lt, DbOf as M, TypeTransform as Mi, sum as Mn, EqualityOperators as Mr, InitialSqlQueryState as Mt, DbQueryState as N, defineType as Ni, OrderColumns as Nn, HasEquality as Nr, SqlQuery as Nt, AnyDb as O, TypeInput as Oi, max as On, ValueRows as Or, SelectQueryKind as Ot, Database as P, AnyColumn as Pi, OrderDirection as Pn, InSignature as Pr, SqlQueryState as Pt, MergeRelations as Q, InsertValues as Qn, AnyTable as Qr, greatest as Qt, TransactionCoordinator as R, ToColumn as Ri, Ordering as Rn, Operand as Rr, MutationQueryState as Rt, AnyExpression as S, TransactionFailure as Si, UnfilteredAggregateOptions as Sn, ExistsValueType as Sr, defineSchema as St, ExpressionOperators as T, BaseType as Ti, count as Tn, OneValueRows as Tr, RecordQueryState as Tt, TestHooks as U, GenericOperator as Ui, ColumnRefs as Un, TypedScalarQuery as Ur, CaseCondition as Ut, TestFixture as V, NoOperators as Vi, desc as Vn, OperandUses as Vr, defineHelper as Vt, TestTransactionOptions as W, GenericOperatorImplementation as Wi, QueryContext as Wn, ValuesQuery as Wr, CaseValue as Wt, TransformedQueryState as X, from as Xn, QueryValueType as Xr, caseWhen as Xt, TransformedQuery as Y, SelectQuery as Yn, QueryStateOf as Yr, TypedOperandOperators as Yt, DeclaredRelations as Z, ColumnValue as Zn, SelectQueryState as Zr, coalesce as Zt, TextOperators as _, ResultRows as _i, AggregateOptions as _n, ConditionOperand as _r, Schema as _t, sql as a, Selectable as ai, GroupedField as an, GroupTerm as ar, RelationKeys as at, NumberTypeOperators as b, DriverResult as bi, GroupValue as bn, not as br, SchemaTables as bt, MatchResult as c, TableKeys as ci, NestedQuery as cn, NotAKey as cr, SchemaContext as ct, defineExpression as d, createTableFactory as di, SelectionFieldTypes as dn, WhereCallback as dr, TableRelations as dt, ColumnDefinitions as ei, ColumnFieldTypes as en, UpdateValues as er, OneRelationKeys as et, FALSE as f, defineTable as fi, SelectionResult as fn, WhereCondition as fr, UsableRelation as ft, TextLengthSignature as g, ResultMode as gi, AggregateExpression as gn, Condition as gr, AnySchema as gt, TextConversionSignature as h, ResultDecodeError as hi, literal as hn, CombinedCondition as hr, one as ht, param as i, KeyColumns as ii, GroupSelectionResult as in, RowLockOptions as ir, RelationKey as it, DbMutationState as j, TypeOutput as ji, stringAgg as jn, EqualityOperator as jr, FieldTypes as jt, BindOptions as k, TypeOperators as ki, min as kn, CountValueType as kr, AnySqlQuery as kt, NotAColumn as l, TableOptions as li, SelectedFieldTypes as ln, PrimaryKeyValues as lr, SchemaRelations as lt, PatternSignature as m, RequiredRelationError as mi, Literal as mn, WhereValues as mr, many as mt, SqlTemplate as n, ColumnShape as ni, ExpressionValue as nn, GroupedState as nr, RelationDeclaration as nt, ColumnRefKey as o, Table as oi, GroupedRecord as on, GroupTerms as or, RelationKind as ot, TRUE as p, NotFoundError as pi, SelectionUses as pn, WhereFilter as pr, UsedRelation as pt, NotSynchronous as q, BoundSelectQuery as qn, InitialQueryState as qr, TypedOperand as qt, identifier as r, ColumnValues as ri, GroupOperandValue as rn, SelectedOperandType as rr, RelationDeclarations as rt, MatchCheck as s, TableFactoryOptions as si, MergeSelection as sn, KeyCheck as sr, RequiredMember as st, toSnakeCase as t, ColumnOperators as ti, ExpressionInput as tn, FilteredStateRows as tr, Relation as tt, matches as u, ToColumns as ui, Selection as un, EqValue as ur, TableContext as ut, TextTypeOperators as v, Connection as vi, CountExpression as vn, Predicate as vr, SchemaPart as vt, Expression as w, AnyType as wi, avg as wn, OneRow as wr, RecordQuery as wt, orderingOperators as x, SqlStatement as xi, StringAggOptions as xn, or as xr, Tables as xt, textOperators as y, Driver as yi, GroupAggregateExpression as yn, and as yr, SchemaPartRelations as yt, OpenedTestFixture as z, BoundOperators as zi, SelectedRefs as zn, OperandValue as zr, Helper as zt };
+export { TransformedQuery as $, Column as $i, QueryContext as $n, Operand as $r, CaseValue as $t, TypedExpression as A, defineTable as Ai, StringAggOptions as An, CombinedCondition as Ar, SelectionState as At, TransactionOptions as B, TransactionFailure as Bi, stringAgg as Bn, OneValueRows as Br, ConflictActionRequired as Bt, textOperators as C, Selectable as Ci, Literal as Cn, PrimaryKeyColumn as Cr, SchemaPartRelations as Ct, BaseOperators as D, TableOptions as Di, CountExpression as Dn, WhereCondition as Dr, AnyRecordQuery as Dt, AnyExpression as E, TableKeys as Ei, AggregateOptions as En, WhereCallback as Er, defineSchema as Et, DbMutationState as F, ResultRows as Fi, countDistinct as Fn, not as Fr, FieldTypes as Ft, TestFixture as G, Type as Gi, OrderTerm as Gn, CompileOptions as Gr, InsertMutationState as Gt, TransactionCoordinator as H, AnyType as Hi, OrderColumns as Hn, ResultByRows as Hr, ConflictTarget as Ht, DbOf as I, Connection as Ii, every as In, or as Ir, InitialSqlQueryState as It, TestTransactionOptions as J, TypeOptions as Ji, SelectedRefs as Jn, HasEquality as Jr, Helper as Jt, TestHelpers as K, TypeInput as Ki, OrderTerms as Kn, EqualityOperator as Kr, MutationQuery as Kt, DbQueryState as L, Driver as Li, max as Ln, ExistsValueType as Lr, SqlQuery as Lt, AnyDb as M, RequiredRelationError as Mi, UnfilteredStringAggOptions as Mn, ConditionOperand as Mr, SelectQueryKind as Mt, BindOptions as N, ResultDecodeError as Ni, avg as Nn, Predicate as Nr, AnySqlQuery as Nt, Expression as O, ToColumns as Oi, GroupAggregateExpression as On, WhereFilter as Or, RecordQuery as Ot, Db as P, ResultMode as Pi, count as Pn, and as Pr, DecodedFields as Pt, SynchronousResult as Q, AnyColumn as Qi, ColumnRefs as Qn, ComparisonSignature as Qr, CaseCondition as Qt, Database as R, DriverResult as Ri, min as Rn, FilteredRows as Rr, SqlQueryState as Rt, TextTypeOperators as S, KeyColumns as Si, SelectionUses as Sn, NotAKey as Sr, SchemaPart as St, orderingOperators as T, TableFactoryOptions as Ti, AggregateExpression as Tn, EqValue as Tr, Tables as Tt, OpenedTestFixture as U, BaseType as Ui, OrderDirection as Un, ValueRows as Ur, InitialInsertState as Ut, createDatabase as V, createStatement as Vi, sum as Vn, QueryResult as Vr, ConflictKeyRequired as Vt, PendingTestFixture as W, TextValue as Wi, OrderKey as Wn, CountValueType as Wr, InitialMutationState as Wt, AnyTransformedQuery as X, TypeTransform as Xi, desc as Xn, equalityOperators as Xr, defineHelper as Xt, createTestHelpers as Y, TypeOutput as Yi, asc as Yn, InSignature as Yr, HelperEffect as Yt, NotSynchronous as Z, defineType as Zi, orderBy as Zn, BooleanResult as Zr, CaseBranch as Zt, TRUE as _, AnyTableKeys as _i, NestedQuery as _n, SelectedOperandType as _r, UsedRelation as _t, sql as a, NoOperators as aa, ValuesQuery as ai, caseWhen as an, SingletonInsertMany as ar, Relation as at, TextLengthSignature as b, ColumnShape as bi, SelectionFieldTypes as bn, GroupTerms as br, AnySchema as bt, MatchResult as c, GenericOperatorImplementation as ca, Grouped as ci, least as cn, ConflictUpdateSet as cr, RelationKey as ct, defineExpression as d, QueryStateOf as di, ExpressionValue as dn, UpdateValues as dr, RequiredMember as dt, ColumnAttributes as ea, OperandValue as ei, FollowingOperand as en, RelationRefs as er, TransformedQueryState as et, ConnectionError as f, QueryValueType as fi, GroupOperandValue as fn, UpsertValues as fr, SchemaContext as ft, FALSE as g, AnyTable as gi, MergeSelection as gn, GroupedState as gr, UsableRelation as gt, toDriverError as h, TableQueryState as hi, GroupedRecord as hn, FoundState as hr, TableRelations as ht, param as i, MergeOperators as ia, TypedScalarQuery as ii, TypedOperandOperators as in, SelectQuery as ir, OneRelationKeys as it, UntypedExpression as j, NotFoundError as ji, UnfilteredAggregateOptions as jn, Condition as jr, AnyQuery as jt, ExpressionOperators as k, createTableFactory as ki, GroupValue as kn, WhereValues as kr, RecordQueryState as kt, NotAColumn as l, OperatorSignature as la, InitialQueryState as li, ColumnFieldTypes as ln, InsertValues as lr, RelationKeys as lt, QueryError as m, SingletonQueryState as mi, GroupedField as mn, FoundQueryState as mr, TableContext as mt, SqlTemplate as n, ToColumn as na, OperandUses as ni, TypedOperand as nn, BoundSelectQuery as nr, MergeRelations as nt, ColumnRefKey as o, OperatorDefinitions as oa, EmptyRecord as oi, coalesce as on, from as or, RelationDeclaration as ot, DriverErrorFields as p, SelectQueryState as pi, GroupSelectionResult as pn, FilteredStateRows as pr, SchemaRelations as pt, TestHooks as q, TypeOperators as qi, Ordering as qn, EqualityOperators as qr, MutationQueryState as qt, identifier as r, BoundOperators as ra, ScalarQuery as ri, TypedOperandInput as rn, ResultOf as rr, NoRelations as rt, MatchCheck as s, GenericOperator as sa, FoundKey as si, greatest as sn, ColumnValue as sr, RelationDeclarations as st, toSnakeCase as t, KeyKind as ta, compare as ti, NullSkippingResult as tn, AnySelectQuery as tr, DeclaredRelations as tt, matches as u, defineGenericOperator as ua, QueryState as ui, ExpressionInput as un, UpdateSet as ur, RelationKind as ut, PatternSignature as v, ColumnDefinitions as vi, SelectedFieldTypes as vn, RowLockOptions as vr, many as vt, NumberTypeOperators as w, Table as wi, literal as wn, PrimaryKeyValues as wr, SchemaTables as wt, TextOperators as x, ColumnValues as xi, SelectionResult as xn, KeyCheck as xr, Schema as xt, TextConversionSignature as y, ColumnOperators as yi, Selection as yn, GroupTerm as yr, one as yt, DatabaseOptions as z, SqlStatement as zi, some as zn, OneRow as zr, AnyMutationQuery as zt };