kern-orm 0.6.0 → 0.7.0

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

@@ -49,7 +49,7 @@ type BoundOperators<O extends OperatorDefinitions, T, I = T> = { [K in keyof O]:
 /** Kind of a key of a table: its primary key, or a unique key. */
 type KeyKind = "primaryKey" | "unique";
 /**
- * Type that `primaryKey()` of a type or a column whose values may be `null` is checked against, naming the reason.
+ * Type that `primaryKey()` of a type or a column that accepts `null` is checked against, naming the reason.
  *
  * Without `strictNullChecks`, `null` belongs to every type, so every column looks nullable; the type then names the option instead.
  */
@@ -86,7 +86,7 @@ declare class Column<T extends AnyType, Key extends KeyKind | undefined = KeyKin
   /** Uses a physical column name different from the column key. */
   columnName(name: string): Column<T, Key, Default>;
   /** Marks the column as the primary key; the type must not be nullable. */
-  primaryKey(this: null extends TypeOutput<T> ? NullablePrimaryKey : Column<T, undefined, Default>): Column<T, "primaryKey", Default>;
+  primaryKey(this: null extends TypeInput<T> ? NullablePrimaryKey : Column<T, undefined, Default>): Column<T, "primaryKey", Default>;
   /** Marks the column as a unique key. */
   unique(this: Column<T, undefined, Default>): Column<T, "unique", Default>;
   /** Marks the column as one that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
@@ -148,19 +148,26 @@ interface BaseType<Output, Input, Operators extends OperatorDefinitions, Paramet
   withParameters<P extends unknown[]>(format: (...parameters: P) => string): Type<Output, Input, Operators, P>;
   /**
    * Creates a type with another representation of the values of this type, keeping its SQL type, operators, and nullability.
+   * An `encode` that takes `null` also makes the result nullable.
    *
    * `decode` receives the values that this type decodes from values other than `NULL`, including `undefined` that an earlier decoder returns, and returns a value other than `null`; `encode` returns values that this type encodes; `NULL` stays `null` without them.
    */
-  transform<NewOutput extends {} | undefined, NewInput>(options: TypeTransform<Exclude<Output, null>, NonNullable<Input>, NewOutput, NewInput>): Type<NewOutput | Extract<Output, null>, NewInput | Extract<Input, null>, Operators, Parameters>;
+  transform<NewOutput extends {} | undefined, NewInput>(options: TypeTransform<Exclude<Output, null>, NonNullable<Input>, NewOutput, NewInput>): Type<NewOutput | AcceptedNull<NewInput | Input>, NewInput | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a type that decodes the values of this type into another representation, other than `null`, and accepts the values that this type accepts. */
   transform<NewOutput extends {} | undefined>(options: {
     decode: (value: Exclude<Output, null>) => NewOutput;
-  }): Type<NewOutput | Extract<Output, null>, Input, Operators, Parameters>;
+  }): Type<NewOutput | AcceptedNull<Input>, Input, Operators, Parameters>;
   nullable(): Type<Output | null, Input | null, Operators, Parameters>;
+  /**
+   * Narrows the values of this type to `T` in TypeScript, such as to a union of strings that a `CHECK` constraint allows, or to the shape of JSON values.
+   *
+   * The values are not validated at runtime. `T` must be among the values that this type both returns and accepts, and `nullable` keeps `null` apart from it.
+   */
+  of<T extends AcceptedValues<Exclude<Output, null>, Exclude<Input, null>>>(): Type<T | AcceptedNull<Input>, T | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a column of this type with a physical name different from the column key. */
   columnName(name: string): Column<Type<Output, Input, Operators, Parameters>, undefined, false>;
   /** Creates a primary key column of this type; the type must not be nullable. */
-  primaryKey(this: null extends Output ? NullablePrimaryKey : Type<Output, Input, Operators, Parameters>): Column<Type<Output, Input, Operators, Parameters>, "primaryKey", false>;
+  primaryKey(this: null extends Input ? NullablePrimaryKey : Type<Output, Input, Operators, Parameters>): Column<Type<Output, Input, Operators, Parameters>, "primaryKey", false>;
   /** Creates a column of this type that is a unique key. */
   unique(): Column<Type<Output, Input, Operators, Parameters>, "unique", false>;
   /** Creates a column of this type that the database gives a value when an insert omits it, such as by `DEFAULT` or an identity, so that inserts may omit it. */
@@ -171,6 +178,18 @@ interface TypeWithParameters<Output, Input, Operators extends OperatorDefinition
   /** Creates this type with PostgreSQL type parameters, such as `varchar.with(255)` for `varchar(255)`; other changes of the type are kept. */
   with(...parameters: Parameters): Type<Output, Input, Operators, Parameters>;
 }
+/**
+ * Values that `of` can narrow a type to: those both among the values `O` that it returns and among the values `I` that it accepts, or `UnacceptedValues` when there are none.
+ *
+ * A narrowed value is also accepted, so its encoder must take it.
+ */
+type AcceptedValues<O, I> = [O] extends [I] ? O : [I] extends [O] ? I : [O & I] extends [never] ? UnacceptedValues : O & I;
+/** `null` when the accepted values `I` include it, also as `unknown`; `never` otherwise. */
+type AcceptedNull<I> = null extends I ? null : never;
+/** Type that `AcceptedValues` names for a type that accepts none of the values it returns. */
+interface UnacceptedValues {
+  readonly "of narrows only a type that accepts the values it returns": never;
+}
 /** Conversion between the values of a type and their new representation. */
 interface TypeTransform<Output, Input, NewOutput, NewInput> {
   decode: (value: Output) => NewOutput;
@@ -230,7 +249,11 @@ interface Driver {
   executeScript(text: string): Promise<void>;
   /** Reserves a dedicated connection, such as for a transaction. */
   acquire(): Promise<Connection>;
-  /** Closes the connections once the transactions on reserved connections end. */
+  /**
+   * Closes the connections once the statements on the pool and the transactions on reserved connections end.
+   *
+   * From the call, it rejects a new statement or script on the pool and a new connection.
+   */
   close(): Promise<void>;
 }
 /** Connection reserved by a driver, such as for a transaction. */
@@ -385,21 +408,23 @@ interface TableKeys<PrimaryKey extends KeyColumns | undefined, UniqueKey extends
   readonly [keysType]: (primaryKey: PrimaryKey, unique: UniqueKey) => readonly [PrimaryKey, UniqueKey];
 }
 /**
- * Immutable table descriptor: physical name, columns, and keys.
+ * Immutable table descriptor: physical name, columns, keys, and whether it holds at most one row.
  *
  * A table knows nothing about relations, schemas, or database connections, so the same table can belong to several schemas.
  * Its object identity is the logical identity of the table.
  */
-interface Table<Name extends string = string, Columns extends ColumnShape = ColumnShape, Keys extends AnyTableKeys = AnyTableKeys> {
+interface Table<Name extends string = string, Columns extends ColumnShape = ColumnShape, Keys extends AnyTableKeys = AnyTableKeys, Singleton extends boolean = boolean> {
   readonly kind: "table";
   readonly name: Name;
   readonly columns: Columns;
   readonly keys: Keys;
+  /** Whether the table holds at most one row, as the `singleton` option of `defineTable` declares; `boolean` where the type of the table does not tell it. */
+  readonly singleton: Singleton;
 }
 /** Table of any name, columns, and keys. */
 type AnyTable = Table<string, ColumnShape>;
 /**
- * Options of `defineTable` over column keys `Column`: the keys of several columns, whose columns are listed in their order.
+ * Options of `defineTable` over column keys `Column`: the keys of several columns, whose columns are listed in their order, and whether the table holds at most one row.
  *
  * The columns of the primary key are of `PrimaryKeyColumn`.
  */
@@ -408,6 +433,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 +470,8 @@ type MatchingKey$1<Key, Columns> = Key extends KeyColumns ? [Key[number]] extend
 type IncludedKey<Key, Columns> = Key extends KeyColumns ? [Key[number]] extends [Columns] ? true : never : never;
 /** Column key of columns `C` as a string, as object keys are at runtime. */
 type ColumnKey<C extends ColumnShape> = `${keyof C & (string | number)}`;
-/** Column key of columns `C` whose type is not nullable, as a string like `ColumnKey`. */
-type NonNullableColumnKey<C extends ColumnShape> = { [K in keyof C]: null extends TypeOutput<C[K]["type"]> ? never : `${K & (string | number)}`; }[keyof C];
+/** Column key of columns `C` whose type does not accept `null`, as a string like `ColumnKey`. */
+type NonNullableColumnKey<C extends ColumnShape> = { [K in keyof C]: null extends TypeInput<C[K]["type"]> ? never : `${K & (string | number)}`; }[keyof C];
 /** Column key of columns `C`, as a string like `ColumnKey`, whose column forms a key of kind `Kind` alone, as `KnownKeyKind` tells. */
 type KeyedColumn<C extends ColumnShape, Kind> = { [K in keyof C]: KnownKeyKind<C[K]["attributes"]["keyKind"]> extends Kind ? `${K & (string | number)}` : never; }[keyof C];
 /** Kind `Kind` of the key that a column forms alone, or `"unknown"` where the type of the column does not tell it. */
@@ -462,6 +493,8 @@ type KnownKeysOf<PrimaryKey extends KeyColumns | undefined, UniqueKey extends Ke
 type DefinedPrimaryKey<C extends ColumnShape, PrimaryKey> = PrimaryKey extends KeyColumns ? PrimaryKey : [KeyedColumn<C, "primaryKey">] extends [never] ? undefined : SingleColumnKey<KeyedColumn<C, "primaryKey">>;
 /** Unique key of a table of columns `C`: `UniqueKey` of its options, or of a column marked with `unique()`. */
 type DefinedUniqueKey<C extends ColumnShape, UniqueKey> = Extract<UniqueKey, KeyColumns> | SingleColumnKey<KeyedColumn<C, "unique">>;
+/** Whether a table of options `O` holds at most one row: `true` or `false` of their `singleton`, `false` without it, or `boolean` where its type does not tell it. */
+type DefinedSingleton<O> = O extends unknown ? [O["singleton" & keyof O]] extends [false | undefined] ? false : [O["singleton" & keyof O]] extends [true] ? true : boolean : never;
 /** Key of each single column of `K`. */
 type SingleColumnKey<K> = K extends string ? readonly [K] : never;
 /** Primary key in options `O`: `undefined` without one, or `"unknown"` where its type does not tell it. */
@@ -479,13 +512,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 +589,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 +755,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 +872,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 +927,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 +1058,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 +1141,17 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    *
    * A value is what `where` takes for its column, such as an expression, but never `null` or `undefined`.
    * Without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
+   * To insert the record of the key or update the existing one, call `upsert` right after it.
    */
-  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S>, Kind>;
+  find<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, ...values: PrimaryKeyValues<S["table"]>): SelectQuery<FoundState<S, PrimaryKeyColumn<S["table"]>>, Kind>;
   /**
    * Filters the query by the values of the columns of one key of the table, primary or unique, and returns the row instead of an array, as `where` followed by `take`, but without a limit.
    *
    * A value is what `where` takes for its column, such as an expression, but never `null` or `undefined`.
    * Without a row, it rejects with `NotFoundError` unless `optional` or `nullable` makes the query resolve to `undefined` or `null`.
+   * To insert the record of the key or update the existing one, call `upsert` right after it.
    */
-  findBy<S extends SelectQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, values: { readonly [C in K]: NonNullable<EqValue<S["table"], C>>; } & KeyCheck<S["table"], K>): SelectQuery<FoundState<S>, Kind>;
+  findBy<S extends SelectQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, values: { readonly [C in K]: NonNullable<EqValue<S["table"], C>>; } & KeyCheck<S["table"], K>): SelectQuery<FoundState<S, K>, Kind>;
   /**
    * Replaces the selected fields with a column, limits the query to one row, and returns the value of the column instead of a record.
    *
@@ -1369,22 +1445,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"]>[]): MutationQuery<InitialMutationState<S["table"], S["schema"], "many">, Kind>;
+  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.
+   */
+  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 +1482,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * `set` gives the values of the columns to update, or is a callback that returns them; a column omitted or given as `undefined` keeps its value.
    * A value is what `insert` takes as a value.
    * A query of `find` or `findBy` rejects with `NotFoundError` without its row, unless `optional` or `nullable` allows it.
-   * A query without a filter must call `all` to update every row.
+   * A query without a filter must call `all` to update every row, unless it is a query of a singleton table, which updates its row.
    * Select the fields that it returns after it, with their values after the update, such as `update(set).select("id")`.
    */
   update<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, set: UpdateSet<S["table"], S["schema"]>): MutationQuery<InitialMutationState<S["table"], S["schema"], S["rows"]>, Kind>;
@@ -1402,7 +1490,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 +1540,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It rejects a query of records, which `ValuesQuery` rejects in types.
    */
   [valuesQueryNode](): NestedQueryNode;
-  /** Creates a query of the same kind and `Db` with the node changes applied. */
+  /** Creates a query of the same kind and `Db` with the node changes applied, dropping the key of `find` and `findBy` unless the changes give it. */
   private derive;
   /**
    * Creates a query of the same kind and `Db` with the node changes applied and then those of `take`, in one derived query.
@@ -1472,7 +1560,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 +1577,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 +1592,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 +1984,16 @@ interface InitialMutationState<T extends AnyTable, C extends SchemaContext, Rows
   readonly value: true;
   readonly uses: U;
 }
+/** State of an insert of `insert` or `insertMany` of table `T` with schema context `C` in rows mode `Rows`, before any other method. */
+interface InitialInsertState<T extends AnyTable, C extends SchemaContext, Rows extends ResultRows> extends InitialMutationState<T, C, Rows> {
+  readonly insert: true;
+}
+/** State of an insert that no method has changed since `insert` or `insertMany`, which `onConflict` applies to. */
+interface InsertMutationState extends MutationQueryState {
+  readonly insert: true;
+}
+/** Rows mode of the rows that an insert of rows mode `Rows` changes when it skips the rows that conflict: a missing row of an insert of one record. */
+type SkippedRows<Rows extends ResultRows> = Rows extends "one" ? "optional" : Rows;
 /** State `S` of a mutation with the parts of `Changes` replaced. */
 type ChangeMutationState<S extends MutationQueryState, Changes extends Partial<MutationQueryState>> = { readonly [K in keyof MutationQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
 /** State of a mutation that returns the number of the rows it changes or their records, which `select` applies to. */
@@ -2034,6 +2146,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 +2169,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 +2425,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 +2879,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 +3208,23 @@ interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
   readonly columns: readonly string[];
   /** Rows of `VALUES`, at least one, each with a value of every column in their order, or `undefined` for `DEFAULT`. */
   readonly values: readonly (readonly (ExpressionNode | undefined)[])[];
+  /** `ON CONFLICT` of the insert, or `undefined` for an insert that rejects a row that conflicts on a key. */
+  readonly conflict?: ConflictNode | undefined;
+}
+/** `ON CONFLICT` of an insert: a row that conflicts on `target` updates the existing row by `update`, or is skipped, as `DO NOTHING`, without it. */
+interface ConflictNode {
+  /**
+   * What a row conflicts on: the keys of the columns of a key of the table, in its order, none for any key, which only `DO NOTHING` takes, or `"singleton"` for the unique index of `(true)` of a singleton table, which holds its one row.
+   */
+  readonly target: readonly string[] | "singleton";
+  readonly update?: ConflictUpdateNode | undefined;
+}
+/** `DO UPDATE SET` of `ON CONFLICT`, whose values see the existing row as the target of the insert and the row proposed for insertion as `excluded`. */
+interface ConflictUpdateNode {
+  /** Assignments of `SET`, at least one, with unique keys. */
+  readonly set: readonly AssignmentNode[];
+  /** Occurrence of the table that stands for the row proposed for insertion, `EXCLUDED` of PostgreSQL, which the values of `set` refer to and which is in no `FROM`. */
+  readonly excluded: TableSourceNode;
 }
 /** Update statement of the rows that its filters choose. */
 interface UpdateNode<Field = ProjectionNode> extends MutationParts<Field> {
@@ -3212,4 +3415,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 { NoRelations as $, BoundOperators as $i, ResultOf as $n, ScalarQuery as $r, TypedOperandInput as $t, Db as A, ResultMode as Ai, count as An, and as Ar, DecodedFields as At, PendingTestFixture as B, TextValue as Bi, OrderKey as Bn, CountValueType as Br, InitialMutationState as Bt, BaseOperators as C, TableOptions as Ci, CountExpression as Cn, WhereCondition as Cr, AnyRecordQuery as Ct, UntypedExpression as D, NotFoundError as Di, UnfilteredAggregateOptions as Dn, Condition as Dr, AnyQuery as Dt, TypedExpression as E, defineTable as Ei, StringAggOptions as En, CombinedCondition as Er, SelectionState as Et, DatabaseOptions as F, SqlStatement as Fi, some as Fn, OneRow as Fr, AnyMutationQuery as Ft, createTestHelpers as G, TypeOutput as Gi, asc as Gn, InSignature as Gr, HelperEffect as Gt, TestHelpers as H, TypeInput as Hi, OrderTerms as Hn, EqualityOperator as Hr, MutationQuery as Ht, TransactionOptions as I, TransactionFailure as Ii, stringAgg as In, OneValueRows as Ir, ConflictActionRequired as It, SynchronousResult as J, AnyColumn as Ji, ColumnRefs as Jn, ComparisonSignature as Jr, CaseCondition as Jt, AnyTransformedQuery as K, TypeTransform as Ki, desc as Kn, equalityOperators as Kr, defineHelper as Kt, createDatabase as L, createStatement as Li, sum as Ln, QueryResult as Lr, ConflictKeyRequired as Lt, DbOf as M, Connection as Mi, every as Mn, or as Mr, InitialSqlQueryState as Mt, DbQueryState as N, Driver as Ni, max as Nn, ExistsValueType as Nr, SqlQuery as Nt, AnyDb as O, RequiredRelationError as Oi, UnfilteredStringAggOptions as On, ConditionOperand as Or, SelectQueryKind as Ot, Database as P, DriverResult as Pi, min as Pn, FilteredRows as Pr, SqlQueryState as Pt, MergeRelations as Q, ToColumn as Qi, BoundSelectQuery as Qn, OperandUses as Qr, TypedOperand as Qt, TransactionCoordinator as R, AnyType as Ri, OrderColumns as Rn, ResultByRows as Rr, ConflictTarget as Rt, AnyExpression as S, TableKeys as Si, AggregateOptions as Sn, WhereCallback as Sr, defineSchema as St, ExpressionOperators as T, createTableFactory as Ti, GroupValue as Tn, WhereValues as Tr, RecordQueryState as Tt, TestHooks as U, TypeOperators as Ui, Ordering as Un, EqualityOperators as Ur, MutationQueryState as Ut, TestFixture as V, Type as Vi, OrderTerm as Vn, CompileOptions as Vr, InsertMutationState as Vt, TestTransactionOptions as W, TypeOptions as Wi, SelectedRefs as Wn, HasEquality as Wr, Helper as Wt, TransformedQueryState as X, ColumnAttributes as Xi, RelationRefs as Xn, OperandValue as Xr, FollowingOperand as Xt, TransformedQuery as Y, Column as Yi, QueryContext as Yn, Operand as Yr, CaseValue as Yt, DeclaredRelations as Z, KeyKind as Zi, AnySelectQuery as Zn, compare as Zr, NullSkippingResult as Zt, TextOperators as _, ColumnValues as _i, SelectionResult as _n, KeyCheck as _r, Schema as _t, sql as a, OperatorSignature as aa, InitialQueryState as ai, ColumnFieldTypes as an, InsertValues as ar, RelationKeys as at, NumberTypeOperators as b, Table as bi, literal as bn, PrimaryKeyValues as br, SchemaTables as bt, MatchResult as c, QueryValueType as ci, GroupOperandValue as cn, UpsertValues as cr, SchemaContext as ct, defineExpression as d, TableQueryState as di, GroupedRecord as dn, FoundState as dr, TableRelations as dt, MergeOperators as ea, TypedScalarQuery as ei, TypedOperandOperators as en, SelectQuery as er, OneRelationKeys as et, FALSE as f, AnyTable as fi, MergeSelection as fn, GroupedState as fr, UsableRelation as ft, TextLengthSignature as g, ColumnShape as gi, SelectionFieldTypes as gn, GroupTerms as gr, AnySchema as gt, TextConversionSignature as h, ColumnOperators as hi, Selection as hn, GroupTerm as hr, one as ht, param as i, GenericOperatorImplementation as ia, Grouped as ii, least as in, ConflictUpdateSet as ir, RelationKey as it, DbMutationState as j, ResultRows as ji, countDistinct as jn, not as jr, FieldTypes as jt, BindOptions as k, ResultDecodeError as ki, avg as kn, Predicate as kr, AnySqlQuery as kt, NotAColumn as l, SelectQueryState as li, GroupSelectionResult as ln, FilteredStateRows as lr, SchemaRelations as lt, PatternSignature as m, ColumnDefinitions as mi, SelectedFieldTypes as mn, RowLockOptions as mr, many as mt, SqlTemplate as n, OperatorDefinitions as na, EmptyRecord as ni, coalesce as nn, from as nr, RelationDeclaration as nt, ColumnRefKey as o, defineGenericOperator as oa, QueryState as oi, ExpressionInput as on, UpdateSet as or, RelationKind as ot, TRUE as p, AnyTableKeys as pi, NestedQuery as pn, SelectedOperandType as pr, UsedRelation as pt, NotSynchronous as q, defineType as qi, orderBy as qn, BooleanResult as qr, CaseBranch as qt, identifier as r, GenericOperator as ra, FoundKey as ri, greatest as rn, ColumnValue as rr, RelationDeclarations as rt, MatchCheck as s, QueryStateOf as si, ExpressionValue as sn, UpdateValues as sr, RequiredMember as st, toSnakeCase as t, NoOperators as ta, ValuesQuery as ti, caseWhen as tn, SingletonInsertMany as tr, Relation as tt, matches as u, SingletonQueryState as ui, GroupedField as un, FoundQueryState as ur, TableContext as ut, TextTypeOperators as v, KeyColumns as vi, SelectionUses as vn, NotAKey as vr, SchemaPart as vt, Expression as w, ToColumns as wi, GroupAggregateExpression as wn, WhereFilter as wr, RecordQuery as wt, orderingOperators as x, TableFactoryOptions as xi, AggregateExpression as xn, EqValue as xr, Tables as xt, textOperators as y, Selectable as yi, Literal as yn, PrimaryKeyColumn as yr, SchemaPartRelations as yt, OpenedTestFixture as z, BaseType as zi, OrderDirection as zn, ValueRows as zr, InitialInsertState as zt };