kern-orm 0.9.0 → 0.10.0

package/dist/{index-2z5iTzXf.d.mts → index-aiyU5HR5.d.mts}

@@ -1,3 +1,5 @@
+import { ResultMode, ResultMode as ResultMode$1, SqlQuery } from "kern-db/builder";
+import { AcceptedNull, AcceptedValues, AnySqlQuery, AnySqlQuery as AnySqlQuery$1, BaseDerivableType, Connection, ConnectionError, Database, Database as Database$1, DatabaseOptions, DecodedFields, DerivableType, DerivableType as DerivableType$1, DerivableTypeWithParameters, Driver, DriverErrorFields, DriverResult, FieldTypes, InitialSqlQueryState, InitialSqlQueryState as InitialSqlQueryState$1, IsolationLevel, NotFoundError as NotFoundError$1, OneRow, OneRow as OneRow$1, OneValueRows, OneValueRows as OneValueRows$1, PollLockOptions, PollLockOptions as PollLockOptions$1, QueryError, QueryErrorCode, QueryErrorCondition, ResultByRows, ResultByRows as ResultByRows$1, ResultDecodeError as ResultDecodeError$1, ResultRows, ResultRows as ResultRows$1, SessionOptions, SessionOptions as SessionOptions$1, SqlFragment as SqlFragment$1, SqlFragment as SqlFragment$2, SqlQuery as SqlQuery$1, SqlQueryResult, SqlQueryState, SqlStatement, SqlStatement as SqlStatement$1, SqlValue, TextValue, TransactionConnectionError, TransactionOptions, TransactionOptions as TransactionOptions$1, TypeOptions, TypeOptions as TypeOptions$1, TypeTransform, TypeTransform as TypeTransform$1, ValueRows, ValueRows as ValueRows$1, createDatabase, createStatement as createStatement$1, isQueryError, toDriverError, typeValues } from "kern-db";
 declare const operatorSignature: unique symbol;
 /** Runtime mark of generic operators. */
 declare const genericOperatorBrand: unique symbol;
@@ -96,13 +98,12 @@ declare class Column<T extends AnyType, Key extends KeyKind | undefined = KeyKin
 type AnyColumn = Column<any>;
 /** Column of a column definition: the column itself, or a column of a type without attributes. */
 type ToColumn<D extends AnyType | AnyColumn> = D extends AnyColumn ? D : D extends AnyType ? Column<D, undefined, false> : never;
-declare const typeValues: unique symbol;
-/** Runtime mark of types, which tells them apart from columns and other objects. */
+/** Runtime mark of types, which tells them apart from columns, types of kern-db without operators, and other objects. */
 declare const typeBrand: unique symbol;
 /**
  * SQL type: a PostgreSQL type, the JavaScript representation of its values, and the operators of its expressions.
  *
- * A type is shared by columns, parameters, and SQL expressions, so the same value is encoded and decoded identically everywhere.
+ * A type is a type of kern-db, shared by columns, parameters, and SQL expressions, so the same value is encoded and decoded identically everywhere.
  * In a table, a type is a column; `columnName`, `primaryKey`, `unique`, and `hasDefault` create a column of the type with these attributes.
  * A type with PostgreSQL type parameters, such as the length of `varchar(255)`, has `with`.
  */
@@ -114,7 +115,6 @@ interface BaseType<Output, Input, Operators extends OperatorDefinitions, Paramet
   readonly [typeValues]: {
     output: Output;
     input: Input;
-    operators: Operators;
   };
   /** SQL type name used in DDL, such as `numeric` or `vector(1536)`. */
   readonly sqlType: string;
@@ -124,13 +124,13 @@ interface BaseType<Output, Input, Operators extends OperatorDefinitions, Paramet
    * It omits type parameters, so that their precision, scale, or length do not constrain a parameter.
    */
   readonly castType: string;
+  readonly isNullable: boolean;
+  /** Converts a non-null value to its PostgreSQL text representation; it does not read `this`. */
+  readonly encode: (value: NonNullable<Input>) => string;
+  /** Converts a non-null PostgreSQL text representation to a value; it does not read `this`. */
+  readonly decode: (text: string) => Exclude<Output, null>;
   /** Operators of expressions of this type, in addition to `isNull` or replacing it. */
   readonly operators: Operators;
-  readonly isNullable: boolean;
-  /** Converts a non-null value to its PostgreSQL text representation. */
-  encode(value: NonNullable<Input>): string;
-  /** Converts a non-null PostgreSQL text representation to a value. */
-  decode(text: string): Exclude<Output, null>;
   /**
    * Creates a type whose expressions also have `operators`.
    *
@@ -178,112 +178,33 @@ 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;
-  encode: (value: NewInput) => Input;
-}
 /** Type of any values, operators, and parameters. */
 type AnyType = Type<any, any, any, any>;
-/** PostgreSQL text representation of a value, as types encode and decode it; `null` is SQL `NULL`. */
-type TextValue = string | null;
 /** Values that a type decodes. */
 type TypeOutput<T extends AnyType> = T[typeof typeValues]["output"];
 /** Values that a type encodes. */
 type TypeInput<T extends AnyType> = T[typeof typeValues]["input"];
 /** Operators of the expressions of a type. */
-type TypeOperators<T extends AnyType> = T[typeof typeValues]["operators"];
-/** Type definition. */
-interface TypeOptions {
-  /** SQL type name, such as `ltree`; `withParameters` adds type parameters to it, and a name with them requires `castType`. */
-  sqlType: string;
-  /** SQL type name that `param` casts parameters to when `sqlType` constrains values, such as `bpchar` for `char`, whose length is 1. */
-  castType?: string;
-}
+type TypeOperators<T extends AnyType> = T["operators"];
+/** Defines a type from `type`, keeping its values and PostgreSQL type parameters, without its operators. */
+declare function defineType$1<Output, Input, Parameters extends unknown[] | undefined>(type: Type<Output, Input, any, Parameters>): Type<Output, Input, NoOperators, Parameters>;
 /**
- * Defines a type whose values are the PostgreSQL text representations as they are.
+ * Defines a type from `dbType`, a type of kern-db, such as one defined without kern-orm, keeping its values and PostgreSQL type parameters.
  *
- * `transform` converts them to other values, such as `number[]` for `vector`.
+ * Its expressions have only `isNull` until `withOperators` adds operators.
  */
-declare function defineType(options: TypeOptions): Type<string>;
-/** SQL statement ready for a driver. */
-interface SqlStatement {
-  readonly text: string;
-  /** Text representations of the parameters; PostgreSQL infers their types from the statement text. */
-  readonly parameters: readonly TextValue[];
-}
-/** Creates a statement from SQL text and the text representations of its parameters, such as `createStatement("BEGIN")`. */
-declare function createStatement(text: string, parameters?: readonly TextValue[]): SqlStatement;
-/** Result of a statement. */
-interface DriverResult {
-  /** Command of the tag that PostgreSQL completed the statement with, such as `SELECT` or `ROLLBACK` for a `COMMIT` of a failed transaction; a driver may give only the first word of a tag of several words, such as `CREATE` of `CREATE TABLE`; `null` for a statement that PostgreSQL completes without a tag, such as an empty text or only a comment. */
-  readonly command: string | null;
-  /** Number of rows that the command tag reports, such as the rows that an `UPDATE` changes, also without `RETURNING`; `0` when PostgreSQL reports none, such as for `BEGIN` or a statement without a command tag. */
-  readonly count: number;
-  /** Names of the result columns in their order, also when the statement returns no rows; none for a statement without result columns, such as `BEGIN` or an `UPDATE` without `RETURNING`. */
-  readonly columns: readonly string[];
-  /** Rows as PostgreSQL text representations of their values, in the order of the result columns. */
-  readonly rows: readonly (readonly TextValue[])[];
-}
+declare function defineType$1<Output, Input, Parameters extends unknown[] | undefined>(dbType: DerivableType<Output, Input, Parameters>): Type<Output, Input, NoOperators, Parameters>;
 /**
- * Physical database access: transport, pooling, and connections.
+ * Defines a type whose values are the PostgreSQL text representations as they are.
  *
- * 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.
+ * `transform` converts them to other values, such as `number[]` for `vector`.
  */
-interface Driver {
-  /**
-   * Executes a statement on any pooled connection.
-   *
-   * It rejects a statement that leaves its connection in a transaction, such as `BEGIN`, with `ConnectionError`, and leaves no transaction open on the pool.
-   */
-  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.
-   *
-   * It rejects a script that leaves its connection in a transaction as `execute` rejects such a statement.
-   * A script whose statement PostgreSQL rejected in that transaction may reject with that `QueryError` instead.
-   * Either way, no transaction stays open on the pool.
-   */
-  executeScript(text: string): Promise<void>;
-  /** Reserves a dedicated connection, such as for a transaction. */
-  acquire(): Promise<Connection>;
-  /**
-   * 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. */
-interface Connection {
-  /**
-   * Executes a statement on the connection.
-   *
-   * Statements and scripts run one at a time in the order of calls, so a statement sent before `COMMIT` or `ROLLBACK` completes before it.
-   */
-  execute(statement: SqlStatement): Promise<DriverResult>;
-  /** Executes a script of statements without parameters on the connection, in the order of calls with its statements. */
-  executeScript(text: string): Promise<void>;
-  /**
-   * Returns the connection to the pool once its statements complete, if PostgreSQL reported an idle transaction status after the last statement; otherwise the driver closes it, which rolls back a transaction left on it.
-   *
-   * The driver tells by itself how the statements on the connection ended.
-   * After a `ConnectionError`, a statement may still run or the connection may be lost, so the driver closes the connection, unless its client refused the statement without breaking the exchange of messages and still reads the status, such as postgres.js 4 for a statement of too many parameters.
-   */
-  release(): void | Promise<void>;
+declare function defineType$1(options: TypeOptions & {
+  readonly [typeValues]?: NotADerivableType;
+}): Type<string>;
+/** Type that the options of `defineType` are checked against when they are a type of kern-db typed without the methods that derive types, naming the reason. */
+interface NotADerivableType {
+  readonly "defineType takes a type of kern-db typed as a DerivableType, as defineType of kern-db creates it": never;
 }
 /** Field of a compiled result: the key of a record and how its value is decoded. */
 type ResultField = ScalarField | NestedField;
@@ -315,19 +236,6 @@ interface ResultConversion {
   /** Converts the whole result, once: an array of rows, one row, or `null` or `undefined` of a missing row. */
   readonly transform: ((result: unknown) => unknown) | undefined;
 }
-/**
- * How a query returns its rows: `many` as an array; `one` as one row, rejecting without it; `nullable` as one row or `null` without it; `optional` as one row or `undefined` without it.
- *
- * Without a row, a query of rows `one` rejects with `NotFoundError`, executed or nested, or with `RequiredRelationError` when a required relation guarantees the row.
- * This mode does not imply a SQL limit: `take` and `get` add `LIMIT 1` only when they change `many` to `one`.
- */
-type ResultRows = "many" | "one" | "nullable" | "optional";
-/** How the rows of a query become its result, apart from its fields. */
-interface ResultMode {
-  readonly rows: ResultRows;
-  /** A row is the value of its only field instead of a record. */
-  readonly value: boolean;
-}
 /** Fields of the rows of a query and how its rows become its result. */
 interface ResultPlan extends ResultMode {
   /** Fields of a row, in the order of its values. */
@@ -343,13 +251,6 @@ interface ResultPlan extends ResultMode {
   /** How code converts the result that the plan decodes; `undefined` for a query without `transform` and `map`. */
   readonly conversion?: ResultConversion | undefined;
 }
-/** Error thrown when a query of one row finds no row, executed or nested, unless a required relation guarantees the row. */
-declare class NotFoundError extends Error {
-  readonly name = "NotFoundError";
-  /** Path of the missing nested rows from the result field that holds them, such as `user` or `fields[2].form`, after the index of the row of an executed query of rows `many`, such as `[2].form`; `undefined` when the executed query itself finds no row. */
-  readonly path: string | undefined;
-  constructor(message: string, path?: string);
-}
 /**
  * Error thrown when a required relation, such as `field.form`, has no record for a row.
  *
@@ -367,25 +268,6 @@ declare class RequiredRelationError extends Error {
   /** Path of the field of the relation from the result field that holds it, such as `fields[2].form`, after the index of the row of an executed query of rows `many`, such as `[2].form`. */
   path: string);
 }
-/** Error thrown when a row does not match the result fields, a value fails to decode, or a callback of `transform` or `map` fails; the failure is its cause. */
-declare class ResultDecodeError extends Error {
-  /**
-   * Path of the value from its result field, such as `fields[2].label`, after the index of the row of an executed query of rows `many`, such as `[2].label`.
-   *
-   * A callback of `map` that fails has the path of its row, such as `fields[2]` or `[2]`, and one of `transform` the path of the field of its nested rows, such as `fields`.
-   * It is `undefined` for a row of the driver of another width than the result fields, and for a callback that fails on the only row or the whole result of an executed query.
-   */
-  readonly path: string | undefined;
-  readonly name = "ResultDecodeError";
-  constructor(message: string,
-  /**
-   * Path of the value from its result field, such as `fields[2].label`, after the index of the row of an executed query of rows `many`, such as `[2].label`.
-   *
-   * A callback of `map` that fails has the path of its row, such as `fields[2]` or `[2]`, and one of `transform` the path of the field of its nested rows, such as `fields`.
-   * It is `undefined` for a row of the driver of another width than the result fields, and for a callback that fails on the only row or the whole result of an executed query.
-   */
-  path: string | undefined, options?: ErrorOptions);
-}
 /** Tells whether `T` is `any`: only `any` turns `1 & T` into a type that `0` extends. */
 type IsAny<T> = 0 extends 1 & T ? true : false;
 /** Flattens an intersection of object types into one object type, so that editors show its fields; `any` stays `any`. */
@@ -800,20 +682,12 @@ interface CountValueType extends QueryValueType {
 type RelationRows<Kind extends RelationKind, Required extends boolean> = Kind extends "many" ? "many" : Required extends true ? "one" : "nullable";
 /** Rows mode after a filter of a query whose row a required relation guarantees: `one` becomes `nullable`, or `optional` for a query of values that `map` does not convert; other modes stay. */
 type FilteredRows<Rows extends ResultRows, Value> = Rows extends "one" ? Value extends true ? "optional" : "nullable" : Rows;
-/** Rows mode after `take`: `many` becomes `one`; the modes of one row stay. */
-type OneRow<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows;
-/** Rows mode after `pluck`: `nullable` becomes `optional`; the other modes stay. */
-type ValueRows<Rows extends ResultRows> = Rows extends "nullable" ? "optional" : Rows;
-/** Rows mode after `get`: `many` becomes `one` and `nullable` becomes `optional`; `one` and `optional` stay. */
-type OneValueRows<Rows extends ResultRows> = Rows extends "many" ? "one" : Rows extends "nullable" ? "optional" : Rows;
 /**
  * Result of a query of state `S`, executed or nested: an array of records or values, or one of them, `null` or `undefined` when a query of rows `nullable` or `optional` finds no row.
  *
  * It is the union of the results of every state that `S` allows, such as of a union of rows modes.
  */
 type QueryResult<S extends QueryState> = S extends QueryState ? ResultByRows<S["result"], S["rows"]> : never;
-/** Result of rows of `Result` returned in rows mode `Rows`; a union of modes gives the union of their results. */
-type ResultByRows<Result, Rows extends ResultRows> = Rows extends "many" ? Result[] : Rows extends "one" ? Result : Rows extends "nullable" ? Result | null : Result | undefined;
 /** Type of the value of a query of `exists`. */
 interface ExistsValueType extends QueryValueType {
   readonly input: boolean;
@@ -1594,8 +1468,8 @@ interface SingletonInsertMany {
 type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
 /** Select query of any state and kind. */
 type AnySelectQuery = SelectQuery<any, SelectQueryKind>;
-/** Type of a record of a query result, or of its value for a query made by `get`, `pluck`, or an aggregate method. */
-type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
+/** Type of a record of a query result, also of a query of SQL text, or of its value for a query made by `get`, `pluck`, or an aggregate method. */
+type ResultOf<Q extends AnyQuery | AnySqlQuery> = 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. */
@@ -2042,17 +1916,17 @@ type HelperMutationState<S extends MutationQueryState, E extends HelperEffect> =
   uses: S["uses"] | E["uses"];
 }> : RecordsState<S, E["fields"], E["uses"]>;
 /** Record that the returned fields of a mutation of state `S` add to: the fields selected earlier, or none. */
-type ReturnedRecord$1<S extends MutationQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
+type ReturnedRecord<S extends MutationQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
 /** State of a mutation of state `S` that returns records with `Fields`, which its nested queries select records of relations `U` for. */
 type RecordsState<S extends MutationQueryState, Fields, U extends UsedRelation = never> = ChangeMutationState<S, {
-  result: MergeSelection<ReturnedRecord$1<S>, Fields>;
+  result: MergeSelection<ReturnedRecord<S>, Fields>;
   rows: S["changed"];
   value: false;
   returning: true;
   uses: S["uses"] | U;
 }>;
 /** State of a mutation of state `S` that returns value `V` of each row it changes in rows mode `Rows`. */
-type ValueState$1<S extends MutationQueryState, V, Rows extends ResultRows> = ChangeMutationState<S, {
+type ValueState<S extends MutationQueryState, V, Rows extends ResultRows> = ChangeMutationState<S, {
   result: V;
   rows: Rows;
   value: true;
@@ -2102,7 +1976,7 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
    *
    * A query of a nullable row resolves to `undefined` without the row.
    */
-  get<S extends OneRowMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], OneValueRows<S["changed"]>>, Kind>;
+  get<S extends OneRowMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState<S, Selectable<S["table"]>[K], OneValueRows<S["changed"]>>, Kind>;
   /**
    * Returns the value of the expression that `callback` returns for the changed row instead of the number of the rows, in a query that changes one row, such as of `insert` or `find`.
    *
@@ -2111,7 +1985,7 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
    */
   get<S extends OneRowMutationState, Kind extends SelectQueryKind, E extends TypedOperand>(this: MutationQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>) => E): MutationQuery<OperandState<S, E, OneValueRows<S["changed"]>>, Kind>;
   /** Returns the value of a column of each changed row instead of the number of the rows, keeping whether the query returns an array or one value. */
-  pluck<S extends UnconvertedMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState$1<S, Selectable<S["table"]>[K], ValueRows<S["changed"]>>, Kind>;
+  pluck<S extends UnconvertedMutationState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: MutationQuery<S, Kind>, key: K): MutationQuery<ValueState<S, Selectable<S["table"]>[K], ValueRows<S["changed"]>>, Kind>;
   /**
    * Returns the value of the expression that `callback` returns for each changed row instead of the number of the rows, keeping whether the query returns an array or one value.
    *
@@ -2244,134 +2118,6 @@ type ConflictKeyCheck<S extends InsertMutationState, K extends string> = [K] ext
 interface ConflictKeyRequired {
   readonly "merge and update need the columns of a key in onConflict": never;
 }
-/** Types of the fields of the rows of a query of SQL text by the names of the result columns they decode. */
-interface FieldTypes {
-  readonly [key: string]: AnyType;
-  readonly [key: symbol]: never;
-}
-/** Record of the values that the types of fields `F` decode. */
-type DecodedFields<F extends FieldTypes> = { -readonly [K in keyof F]: TypeOutput<F[K]>; };
-/**
- * State in types of a query of SQL text: the rows mode of the rows that its statement returns, and its result, which is the number of the rows of its command tag until a selection returns their fields.
- *
- * Methods change only their own parts of the state.
- */
-interface SqlQueryState extends QueryState {
-  /** Rows mode of the rows of the statement, which `select`, `get`, and `pluck` return. */
-  readonly returned: ResultRows;
-  /** Whether the query returns the fields of the rows of the statement rather than their number. */
-  readonly returning: boolean;
-}
-/** State of a query of SQL text that returns the number of the rows of its command tag. */
-interface InitialSqlQueryState extends SqlQueryState {
-  readonly result: number;
-  readonly rows: "one";
-  readonly value: true;
-  readonly uses: never;
-  readonly returned: "many";
-  readonly returning: false;
-}
-/** State `S` of a query of SQL text with the parts of `Changes` replaced. */
-type ChangeSqlQueryState<S extends SqlQueryState, Changes extends Partial<SqlQueryState>> = { readonly [K in keyof SqlQueryState]: K extends keyof Changes ? Changes[K] : S[K]; } & {};
-/** State of a query of SQL text that returns the number of the rows or their records, which `select` applies to. */
-type RecordSqlQueryState = SqlQueryState & ({
-  readonly returning: false;
-} | {
-  readonly value: false;
-});
-/** State of a query of SQL text of one row, which `optional` applies to. */
-type OneRowSqlQueryState = SqlQueryState & {
-  readonly returned: "one" | "nullable" | "optional";
-};
-/** State of a query of SQL text of one row that returns its number or its record, which `nullable` applies to. */
-type OneRecordSqlQueryState = OneRowSqlQueryState & RecordSqlQueryState;
-/** Record that the fields of a query of SQL text of state `S` add to: the fields selected earlier, or none. */
-type ReturnedRecord<S extends SqlQueryState> = S["returning"] extends true ? S["result"] : EmptyRecord;
-/** State of a query of SQL text of state `S` whose rows are in rows mode `Rows`. */
-type RowsState<S extends SqlQueryState, Rows extends ResultRows> = ChangeSqlQueryState<S, {
-  returned: Rows;
-  rows: S["returning"] extends true ? Rows : "one";
-}>;
-/** State of a query of SQL text of state `S` that returns value `V` of each row in rows mode `Rows`. */
-type ValueState<S extends SqlQueryState, V, Rows extends ResultRows> = ChangeSqlQueryState<S, {
-  result: V;
-  rows: Rows;
-  returned: Rows;
-  value: true;
-  returning: true;
-}>;
-/**
- * Immutable query of a statement of SQL text, bound to the `Db` that executes it when awaited.
- *
- * Without a selection, it resolves to the number of the rows of the command tag of its statement, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of the rows of the statement instead, decoded by types.
- */
-declare class SqlQuery<out S extends SqlQueryState> {
-  readonly node: TextStatementNode;
-  /** `Db` that executes the query when it is awaited. */
-  readonly db: AnyDb;
-  readonly types: S;
-  /** Executes the query on its `Db`. */
-  readonly then: QueryThen<S, "bound">;
-  constructor(node: TextStatementNode,
-  /** `Db` that executes the query when it is awaited. */
-  db: AnyDb);
-  /**
-   * Returns the records of the rows of the statement instead of their number, with the values of the result columns named by the keys of `fields`, decoded by their types; it adds the fields to those selected earlier, replacing fields under their keys.
-   *
-   * A type of a column that can be `NULL` must be nullable.
-   * The statement rejects without a column of a field, or with the column twice; other columns are ignored.
-   */
-  select<S extends RecordSqlQueryState, F extends FieldTypes>(this: SqlQuery<S>, fields: F): SqlQuery<ChangeSqlQueryState<S, {
-    result: MergeSelection<ReturnedRecord<S>, DecodedFields<F>>;
-    rows: S["returned"];
-    value: false;
-    returning: true;
-  }>>;
-  /**
-   * Returns the value of the only column of the row of the statement instead of the number of the rows, decoded by `type`.
-   *
-   * Without a row, it rejects with `NotFoundError` unless `optional` makes the query resolve to `undefined`; it rejects several rows.
-   * A `NULL` value is `null`, so a type of a column that can be `NULL` must be nullable.
-   */
-  get<S extends SqlQueryState, T extends AnyType>(this: SqlQuery<S>, type: T): SqlQuery<ValueState<S, TypeOutput<T>, OneValueRows<S["returned"]>>>;
-  /**
-   * Returns the values of the only column of the rows of the statement instead of their number, decoded by `type`, keeping whether the query returns an array or one value.
-   *
-   * A `NULL` value is `null`, so a type of a column that can be `NULL` must be nullable.
-   */
-  pluck<S extends SqlQueryState, T extends AnyType>(this: SqlQuery<S>, type: T): SqlQuery<ValueState<S, TypeOutput<T>, ValueRows<S["returned"]>>>;
-  /**
-   * Returns the row of the statement instead of an array, and rejects with `NotFoundError` without it and with several rows; it adds no limit to the statement.
-   *
-   * Before a selection, the query resolves to the number of the rows, `1`, and rejects as well.
-   */
-  take<S extends SqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, OneRow<S["returned"]>>>;
-  /**
-   * Makes a query of one row, such as one of `take` or `get`, resolve to `undefined` without the row.
-   *
-   * Before a selection, the query resolves to `0` without the row.
-   */
-  optional<S extends OneRowSqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, "optional">>;
-  /**
-   * Makes a query of one record, such as one of `take`, resolve to `null` without the row.
-   *
-   * A value of `get` or `pluck` is never `null` for a missing row, which would read as a `NULL` value, so a query of values does not accept it.
-   * Before a selection, the query resolves to `0` without the row.
-   */
-  nullable<S extends OneRecordSqlQueryState>(this: SqlQuery<S>): SqlQuery<RowsState<S, "nullable">>;
-  /** Compiles the query into SQL text and parameters, as its `Db` executes it. */
-  toSQL(): SqlStatement;
-  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
-  [operandNode](): never;
-  /** Creates a query of the same `Db` with the node changes applied. */
-  private derive;
-  /** Creates the query that returns the value of the only column of each row in rows mode `rows`, decoded by `type` of `method`. */
-  private deriveValue;
-  /** Creates the query of one row in rows mode `rows`, rejecting a query of many rows. */
-  private changeOneRow;
-}
-/** Query of SQL text of any state. */
-type AnySqlQuery = SqlQuery<any>;
 /** Kind of a select query: `unbound`, or `bound` to a `Db`. */
 type SelectQueryKind = "unbound" | "bound";
 /**
@@ -2384,8 +2130,8 @@ type QueryThen<S extends QueryState, Kind extends SelectQueryKind> = [Kind] exte
 type QueryDb<Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? AnyDb : [Kind] extends ["unbound"] ? undefined : AnyDb | undefined;
 /** Arguments of `toSQL` of a query of kind `Kind`: a bound query compiles with the options of its `Db`. */
 type ToSQLArgs<Kind extends SelectQueryKind> = [Kind] extends ["bound"] ? [] : [options?: CompileOptions];
-/** Query of any class, state, and kind: a select query of a table, one converted by `transform`, a query of `$select`, one that inserts, updates, or deletes rows, or a query of SQL text. */
-type AnyQuery = AnySelectQuery | AnyTransformedQuery | AnyRecordQuery | AnyMutationQuery | AnySqlQuery;
+/** Query of any class, state, and kind: a select query of a table, one converted by `transform`, a query of `$select`, or one that inserts, updates, or deletes rows. */
+type AnyQuery = AnySelectQuery | AnyTransformedQuery | AnyRecordQuery | AnyMutationQuery;
 /** State of a query of `$select` in types: one record `R`, whose nested queries select records of relations `U`. */
 interface RecordQueryState<R = unknown, U extends UsedRelation = UsedRelation> extends QueryState {
   readonly result: R;
@@ -2674,250 +2420,21 @@ declare class TransformedQuery<out S extends TransformedQueryState, out Kind ext
 }
 /** Query of `transform` of a table of any state and kind. */
 type AnyTransformedQuery = TransformedQuery<any, SelectQueryKind>;
-/** Test fixture of `useTestFixture`, open while the tests of its `describe` block or test file run. */
-interface TestFixture<T = unknown> {
-  /** Result of the seed of the fixture; reading it while the fixture is not open throws. */
-  readonly data: T;
-}
-/** Test fixture opened by the transaction coordinator: an outer transaction of a database created for tests, which always rolls back when it closes. */
-interface OpenedTestFixture<T = unknown> extends AsyncDisposable {
-  /** Result of the seed of the fixture, such as the records it created; reading it after the fixture closes throws. */
-  readonly data: T;
-  /** Rolls back the fixture and the fixtures opened inside it; closing a closed fixture does nothing. */
-  close(): Promise<void>;
-}
-/** Test fixture that is being opened, with a `close` that can be called before it opens. */
-interface PendingTestFixture<T = unknown> {
-  readonly fixture: Promise<OpenedTestFixture<T>>;
-  close(): Promise<void>;
-}
-/**
- * Hooks of a test runner that run a function before and after the tests of the current `describe` block or test file.
- *
- * They are `before` and `after` of `node:test`, and `beforeAll` and `afterAll` of `bun:test` and Vitest.
- */
-interface TestHooks {
-  before(hook: () => Promise<void>): unknown;
-  after(hook: () => Promise<void>): unknown;
-}
-/** Options of `testTransaction`. */
-interface TestTransactionOptions {
-  /**
-   * Abort signal of the test, such as `t.signal` of `node:test` or `signal` of the test context of Vitest.
-   *
-   * When it aborts, the test transaction rejects the later queries of the test at once and rolls back without waiting for the test.
-   * It then rejects with the reason of the signal.
-   * If starting or rolling back the transaction fails, it rejects instead with a `SuppressedError` that keeps the reason.
-   * Queries that the test has already sent complete before the rollback.
-   */
-  signal?: AbortSignal;
-  /**
-   * Isolation level of the test transaction, such as `serializable`, for code under test that starts a transaction at that level.
-   *
-   * Inside a test fixture, the test transaction runs at the level of the fixture: given another level, it rejects.
-   */
-  isolation?: IsolationLevel;
-}
-/** Options of `useTestFixture`. */
-interface TestFixtureOptions {
-  /**
-   * Isolation level of the transaction of the fixture, such as `serializable`, at which the test transactions and fixtures nested in it run.
-   *
-   * A fixture nested in another one runs at the level of that fixture: given another level, it rejects.
-   */
-  isolation?: IsolationLevel;
-}
-/** Test transactions and test fixtures of a database created with `test: true`. */
-interface TestHelpers {
-  /**
-   * Runs `callback` in a transaction that always rolls back.
-   *
-   * Wrap the body of every test in it, so that every run of the test gets its own transaction.
-   * Inside an existing transaction, it starts a nested transaction that always rolls back.
-   */
-  testTransaction<T>(callback: () => Promise<T>, options?: TestTransactionOptions): Promise<T>;
-  /**
-   * Opens a test fixture for the tests of the current `describe` block or test file and runs `seed` in it, such as migrations or data shared by the tests.
-   *
-   * The fixture opens in the `before` hook and rolls back in the `after` hook.
-   * The changes of `seed` stay for the test transactions that run while the fixture is open, and its result is the `data` of the fixture.
-   * Test fixtures nest: a new one opens inside the innermost open one, and test transactions run in the innermost one.
-   * A fixture whose `seed` rejects rolls back and closes.
-   */
-  useTestFixture<T>(seed: () => Promise<T>, options?: TestFixtureOptions): TestFixture<T>;
-}
-/** Creates the test helpers of a database created with `test: true`, registering fixtures with the hooks of a test runner. */
-declare function createTestHelpers(database: Database, hooks: TestHooks): TestHelpers;
-/**
- * Routes statements and scripts to the ambient transaction of the current async context or to the pool.
- *
- * This is the only place that decides which connection executes a statement.
- */
-declare class TransactionCoordinator {
-  #private;
-  readonly driver: Driver;
-  /** Rejects statements and transactions outside a test transaction or the seed of a test fixture instead of running them on the pool. */
-  readonly test: boolean;
-  constructor(driver: Driver, { test, onReleaseError }?: Omit<DatabaseOptions, "driver">);
-  execute(statement: SqlStatement): Promise<DriverResult>;
-  /** Executes a script of statements without parameters where `execute` executes a statement. */
-  executeScript(text: string): Promise<void>;
-  /**
-   * Runs `callback` in a transaction that commits when it resolves and rolls back when it rejects, with the settings of `options`.
-   *
-   * Inside a transaction, it runs `callback` in a savepoint nested in it, which restores the settings it changed when it ends, and rejects without the savepoint when the isolation level of `options` differs from that of the transaction.
-   * A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
-   * A transaction that it starts rolls back instead of `COMMIT` after a `ConnectionError` on its connection, and when it rejects after such an error, also of `COMMIT`, it rejects with `TransactionConnectionError` of the phase of the failure, whose `cause` is the error it would reject with otherwise.
-   */
-  transaction<T>(callback: () => Promise<T>, options?: TransactionOptions): Promise<T>;
-  /**
-   * Runs `callback` in the current transaction, or in a new transaction outside of one.
-   *
-   * Joining starts no savepoint, so a rejection of `callback` does not undo its changes.
-   * It rejects without calling `callback` when the current level accepts no statements, as a nested transaction would.
-   */
-  ensureTransaction<T>(callback: () => Promise<T>): Promise<T>;
-  /**
-   * Tells whether the current async context runs in a transaction of `transaction`.
-   *
-   * A test transaction and the seed of a test fixture are not transactions, unless they run inside one, so that code under test behaves as in production.
-   */
-  isInTransaction(): boolean;
-  /**
-   * Runs `callback` in a transaction that always rolls back, on a coordinator created for tests.
-   *
-   * Inside a transaction, it runs `callback` in a savepoint nested in it that always rolls back.
-   * When `signal` aborts, the level stops accepting statements at once and ends without waiting for `callback`.
-   * Once the level ends, the transaction rejects with the reason of the signal.
-   * A failure to start or end the level after the abort suppresses the reason in a `SuppressedError`.
-   * Aborted while it waits for its turn in the fixture stack or for a connection, it rejects at once; after the abort, it never calls `callback`.
-   */
-  testTransaction<T>(callback: () => Promise<T>, options?: TestTransactionOptions): Promise<T>;
-  /**
-   * Opens a test fixture: a transaction on a reserved connection, or a savepoint in the innermost open fixture, and runs `seed` in it.
-   *
-   * Test transactions started outside any transaction run in the innermost fixture.
-   * A fixture whose `seed` rejects rolls back and closes.
-   */
-  createTestFixture<T>(seed: () => Promise<T>, options?: TestFixtureOptions): Promise<OpenedTestFixture<T>>;
-  /**
-   * Starts opening a test fixture, see `createTestFixture`, and returns it with a `close` that can be called before it opens.
-   *
-   * Closing before the fixture opens rejects the opening without waiting for `seed` and rolls the fixture back, so a fixture or test transaction started after `close` never nests in it, even when its `seed` never settles.
-   * Closing an open fixture also closes the fixtures opening in it.
-   */
-  startTestFixture<T>(seed: () => Promise<T>, options?: TestFixtureOptions): PendingTestFixture<T>;
-  /**
-   * Closes the test fixtures, including those still opening, and then the driver, which waits for the running transactions to end.
-   *
-   * A driver waits for every reserved connection, so closing it under an open fixture would wait forever.
-   * A failed closing of the driver suppresses the failures of closing the fixtures.
-   * From the first call, statements, transactions, and fixtures started outside a transaction reject, while the levels already running can still end; a repeated call returns the same closing.
-   */
-  close(): Promise<void>;
-}
-/**
- * Physical database shared by all schemas bound to it.
- *
- * Its ambient transaction spans every schema bound to the same database, such as tenant and SaaS schemas.
- * Disposing it, such as with `await using`, closes it.
- */
-interface Database extends AsyncDisposable {
-  /** Routes the statements and transactions of the database; `kern-orm/testing` runs test transactions and test fixtures through it. */
-  readonly coordinator: TransactionCoordinator;
-  /**
-   * Binds a schema to this database, placing its tables in a PostgreSQL schema.
-   *
-   * A database can bind several schemas, which share its connections and transactions.
-   */
-  bind<T extends Tables, R extends SchemaRelations>(schema: Schema<T, R>, options?: BindOptions): Db<T, R>;
-  /**
-   * Starts a query of the SQL statement of the template, as `$query` of a `Db` does, for code without a `Db`.
-   *
-   * It names no tables of a `Db`: run a statement that interpolates them with `$query` of that `Db`.
-   */
-  query(strings: TemplateStringsArray, ...values: unknown[]): SqlQuery<InitialSqlQueryState>;
-  /** Executes a script of statements without parameters, as `$script` of a `Db` does, for code without a `Db`. */
-  script(text: string): Promise<void>;
-  /**
-   * Executes the script of the template, as `$script` of a `Db` does, for code without a `Db`.
-   *
-   * It names no tables of a `Db`: run a script that interpolates them with `$script` of that `Db`.
-   */
-  script(strings: TemplateStringsArray, ...values: unknown[]): Promise<void>;
-  /** Executes a compiled statement, such as of `$compile` of a `Db`, in the ambient transaction, or on the pool outside of one unless the database was created with `test: true`. */
-  execute(statement: SqlStatement): Promise<DriverResult>;
-  /**
-   * Runs `callback` in a transaction that queries of every bound schema join automatically.
-   *
-   * Inside an existing transaction, it starts a nested transaction.
-   */
-  transaction<T>(callback: () => Promise<T>, options?: TransactionOptions): Promise<T>;
-  /**
-   * Runs `callback` in the current transaction without a nested transaction, or in a new transaction outside of one.
-   *
-   * A rejection of a callback that joined a transaction does not undo its changes: the enclosing transaction commits them unless it fails too.
-   * A test transaction is not a transaction to join: there, it starts a nested transaction where it starts a transaction in production.
-   */
-  ensureTransaction<T>(callback: () => Promise<T>): Promise<T>;
-  /** Tells whether the code runs in a transaction, not counting test transactions, so that code under test sees what it sees in production. */
-  isInTransaction(): boolean;
-  /**
-   * Takes the advisory lock of `key` until the transaction ends, waiting while another transaction holds it, such as to keep processes from running the same job at once.
-   *
-   * It rejects where `isInTransaction()` is `false`, since outside a transaction the lock would end with its statement.
-   * A nested transaction that rolls back releases the locks it took.
-   */
-  lock(key: string): Promise<void>;
-  /** Rolls back the open test fixtures and closes the connections of the driver once the running transactions end. */
-  close(): Promise<void>;
-}
-/** Isolation level of a transaction in PostgreSQL. */
-type IsolationLevel = "read committed" | "repeatable read" | "serializable";
-/** Options of `transaction` of a `Database` and `$transaction` of a `Db`. */
-interface TransactionOptions {
-  /**
-   * Isolation level of the transaction, such as `serializable`.
-   *
-   * A nested transaction runs at the level of its transaction: given another level, it rejects.
-   */
-  isolation?: IsolationLevel;
-  /**
-   * PostgreSQL schemas where the unqualified names of the statements of the transaction resolve, in their order, such as the schema of a tenant followed by the schema of extensions.
-   *
-   * It applies to the statements of the callback, including those of its nested transactions, until the transaction ends; a nested transaction then restores the search path of the enclosing transaction.
-   */
-  searchPath?: readonly string[];
-}
-/** Options of `createDatabase`. */
-interface DatabaseOptions {
-  driver: Driver;
-  /** Rejects queries and transactions outside the test transactions and the seeds of test fixtures of `kern-orm/testing`, so that every statement of the tests runs in a transaction that rolls back. */
-  test?: boolean;
-  /**
-   * Receives a failure to release the connection of a transaction, such as to log it; the failure does not change the result or error of the transaction.
-   *
-   * Without it, the failure goes to `console.error`.
-   */
-  onReleaseError?: (error: unknown) => void;
-}
-/** Creates a database over a driver; its transactions are shared by every schema bound to it. */
-declare function createDatabase({ driver, ...options }: DatabaseOptions): Database;
 /** Physical placement of the tables of a schema bound to a database. */
 interface BindOptions {
   /** PostgreSQL schema of the tables; a function is called on every query, such as to resolve the current tenant. */
   schemaName?: string | (() => string);
 }
 /**
- * Schema bound to a database with `database.bind`.
+ * Schema bound to a database with `bindSchema`.
  *
  * 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, 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>;
+/** 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`. */
+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>;
 /** State of a query that a `Db` can execute: over table `T`, selecting records only of relations `U`. */
 interface DbQueryState<T extends AnyTable, U extends UsedRelation> extends QueryStateOf<T> {
   readonly uses: U;
@@ -2962,7 +2479,7 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
    */
   $query(strings: TemplateStringsArray, ...values: unknown[]): SqlQuery<InitialSqlQueryState>;
   /**
-   * Executes a script of statements without parameters, such as DDL separated by semicolons, in the ambient transaction, or on the pool outside of one, where PostgreSQL runs them in one implicit transaction.
+   * Executes a script of statements without parameters, such as DDL separated by semicolons, in the ambient transaction or session, or on the pool outside of one; outside a transaction, PostgreSQL runs them in one implicit transaction.
    *
    * The script must not start or end transactions, which the database tracks.
    */
@@ -2989,12 +2506,40 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
   /** Tells whether the code runs in a transaction of the database, not counting test transactions, so that code under test sees what it sees in production. */
   $isInTransaction(): boolean;
   /**
-   * Takes the advisory lock of `key` until the transaction of the database ends, waiting while another transaction holds it, such as to keep processes from running the same job at once.
+   * Tells whether a statement of the code runs in a transaction block of PostgreSQL, counting test transactions, such as to choose a statement that PostgreSQL rejects there, `CREATE INDEX CONCURRENTLY`.
+   *
+   * It is `false` in a session outside its transactions.
+   */
+  $isInTransactionBlock(): boolean;
+  /**
+   * Runs `callback` in a session of the database: on one connection outside a transaction, such as for statements that PostgreSQL rejects in a transaction block and that share a setting of the connection, such as its search path.
+   *
+   * Statements of every schema bound to the database join the session automatically, each in a transaction of its own, and `$transaction` in the callback starts a transaction on the connection of the session.
+   * A rejection of `callback` undoes nothing.
+   * It rejects inside a transaction, also a test transaction, inside another session, and on a database created with `test: true`.
+   */
+  $session<Result>(callback: () => Promise<Result>, options?: SessionOptions): Promise<Result>;
+  /**
+   * Takes the advisory lock of `key` until the transaction of the database ends, waiting while another transaction or session holds it, such as to keep processes from running the same job at once.
    *
-   * It rejects where `$isInTransaction()` is `false`, since outside a transaction the lock would end with its statement.
+   * It rejects where `$isInTransaction()` is `false`, since outside a transaction the lock would end with its statement; in a session, take the lock with `$tryLock`, which does not wait.
    * A nested transaction that rolls back releases the locks it took.
    */
   $lock(key: string): Promise<void>;
+  /**
+   * Takes the advisory lock of `key` unless another transaction or session holds it, and tells whether it took it, such as to skip a job that another process is running.
+   *
+   * In a transaction of the database, it holds the lock until the transaction ends, as `$lock` does; in a session outside its transactions, until the session ends.
+   * It rejects outside both, since the lock would end with its statement; a test transaction alone does not count.
+   */
+  $tryLock(key: string): Promise<boolean>;
+  /**
+   * Takes the advisory lock of `key` in a session of the database until the session ends, calling `$tryLock` again after a pause until it takes the lock, such as to let one process at a time run statements outside a transaction.
+   *
+   * It rejects outside a session, and in a transaction, where `$lock` waits for the lock.
+   * Once `signal` of `options` aborts, such as `AbortSignal.timeout(60_000)`, it makes no more attempts and rejects with the reason of the signal, unless the attempt that is running takes the lock.
+   */
+  $pollLock(key: string, options?: PollLockOptions): Promise<void>;
 }
 /**
  * `Db` of schema `S`, such as the type of a parameter of code shared by several schemas.
@@ -3004,6 +2549,12 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
 type DbOf<S extends AnySchema> = Db<S["$tables"], S[typeof schemaRelations]>;
 /** `Db` of any schema. */
 type AnyDb = Db<any, any>;
+/**
+ * Binds a schema to a database, placing its tables in a PostgreSQL schema.
+ *
+ * Schemas bound to the same database, such as tenant and SaaS schemas, share its connections and transactions.
+ */
+declare function bindSchema<T extends Tables, R extends SchemaRelations>(schema: Schema<T, R>, database: Database, options?: BindOptions): Db<T, R>;
 /** Occurrence of a table in `FROM`. */
 interface TableSourceNode {
   readonly kind: "table";
@@ -3114,6 +2665,11 @@ interface RawSqlNode {
   readonly fragments: readonly string[];
   readonly values: readonly ExpressionNode[];
 }
+/** SQL fragment of the database layer, such as a quoted name of `identifier`, which the layer renders with the parameters of the statement. */
+interface FragmentNode {
+  readonly kind: "fragment";
+  readonly fragment: SqlFragment$1;
+}
 /** Name of a table interpolated into a SQL fragment, qualified by the PostgreSQL schema of the statement. */
 interface TableNameNode {
   readonly kind: "tableName";
@@ -3147,7 +2703,7 @@ interface AggregateNode {
   /** Condition of the rows that the function takes, as `FILTER (WHERE ...)`, or `undefined` for every row. */
   readonly filter: ExpressionNode | undefined;
 }
-type ExpressionNode = ColumnRefNode | ParamNode | CastNode | BooleanNode | AndNode | OrNode | NotNode | ValuesNode | NestedQueryNode | ComparisonNode | InNode | InQueryNode | IsNullNode | RawSqlNode | TableNameNode | SubqueryNode | ExistsNode | TextSubqueryNode | AggregateNode;
+type ExpressionNode = ColumnRefNode | ParamNode | CastNode | BooleanNode | AndNode | OrNode | NotNode | ValuesNode | NestedQueryNode | ComparisonNode | InNode | InQueryNode | IsNullNode | RawSqlNode | FragmentNode | TableNameNode | SubqueryNode | ExistsNode | TextSubqueryNode | AggregateNode;
 /**
  * Filters of a query, kept apart so that composing one kind never changes the others.
  *
@@ -3275,17 +2831,6 @@ interface DeleteNode<Field = ProjectionNode> extends MutationParts<Field> {
 }
 /** Statement that inserts, updates, or deletes rows, with the fields of `RETURNING` of type `Field`. */
 type MutationStatementNode<Field = ProjectionNode> = InsertNode<Field> | UpdateNode<Field> | DeleteNode<Field>;
-/**
- * Statement of SQL text written by a user, such as of `$query`.
- *
- * Its result mode is the rows mode of the rows that the statement returns and whether a row is the value of its only column.
- */
-interface TextStatementNode extends ResultMode {
-  readonly kind: "text";
-  readonly sql: RawSqlNode;
-  /** Fields decoded from the result columns of their keys, or from the only column for a value; `undefined` for a statement that resolves to the number of the rows of its command tag. */
-  readonly fields: readonly ScalarField[] | undefined;
-}
 declare const valueType: unique symbol;
 declare const inputType: unique symbol;
 declare const typed: unique symbol;
@@ -3367,362 +2912,6 @@ 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: string;
-  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;
-/** Phase of a transaction in which its connection failed. */
-type TransactionPhase = TransactionConnectionError["phase"];
-/**
- * Error of a transaction whose connection failed, which tells whether the transaction may have been committed.
- *
- * Its `cause` is the error that the transaction would reject with otherwise, such as the error of the callback, or a `SuppressedError` of a failed rollback that keeps it.
- */
-declare class TransactionConnectionError extends ConnectionError {
-  readonly name: string;
-  /**
-   * Phase of the transaction in which its connection failed:
-   *
-   * - `begin`: before the callback, such as getting the connection or `BEGIN`, so the transaction applied nothing;
-   * - `transaction`: in the callback or its rollback, so the transaction was rolled back;
-   * - `commit`: during `COMMIT`, so whether the transaction was committed is unknown.
-   */
-  readonly phase: "begin" | "transaction" | "commit";
-  constructor(phase: TransactionPhase, options?: {
-    cause?: unknown;
-  });
-  /** Tells whether `value` is an instance of the class, including one of `TransactionConnectionError` of another copy of kern-orm. */
-  static [Symbol.hasInstance]<T>(this: abstract new (...args: never) => T, value: unknown): value is T;
-}
-/**
- * Condition names of the SQLSTATE codes of PostgreSQL errors, by code: the codes of type `E` with a condition name, which PL/pgSQL takes in `EXCEPTION WHEN`, under the headings of their classes.
- *
- * A code that ends in `000` is the condition of its class.
- * A few names have two codes, such as `null_value_not_allowed`.
- */
-declare const conditionsByCode: {
-  readonly "03000": "sql_statement_not_yet_complete";
-  readonly "08000": "connection_exception";
-  readonly "08003": "connection_does_not_exist";
-  readonly "08006": "connection_failure";
-  readonly "08001": "sqlclient_unable_to_establish_sqlconnection";
-  readonly "08004": "sqlserver_rejected_establishment_of_sqlconnection";
-  readonly "08007": "transaction_resolution_unknown";
-  readonly "08P01": "protocol_violation";
-  readonly "09000": "triggered_action_exception";
-  readonly "0A000": "feature_not_supported";
-  readonly "0B000": "invalid_transaction_initiation";
-  readonly "0F000": "locator_exception";
-  readonly "0F001": "invalid_locator_specification";
-  readonly "0L000": "invalid_grantor";
-  readonly "0LP01": "invalid_grant_operation";
-  readonly "0P000": "invalid_role_specification";
-  readonly "0Z000": "diagnostics_exception";
-  readonly "0Z002": "stacked_diagnostics_accessed_without_active_handler";
-  readonly "10608": "invalid_argument_for_xquery";
-  readonly "20000": "case_not_found";
-  readonly "21000": "cardinality_violation";
-  readonly "22000": "data_exception";
-  readonly "2202E": "array_subscript_error";
-  readonly "22021": "character_not_in_repertoire";
-  readonly "22008": "datetime_field_overflow";
-  readonly "22012": "division_by_zero";
-  readonly "22005": "error_in_assignment";
-  readonly "2200B": "escape_character_conflict";
-  readonly "22022": "indicator_overflow";
-  readonly "22015": "interval_field_overflow";
-  readonly "2201E": "invalid_argument_for_logarithm";
-  readonly "22014": "invalid_argument_for_ntile_function";
-  readonly "22016": "invalid_argument_for_nth_value_function";
-  readonly "2201F": "invalid_argument_for_power_function";
-  readonly "2201G": "invalid_argument_for_width_bucket_function";
-  readonly "22018": "invalid_character_value_for_cast";
-  readonly "22007": "invalid_datetime_format";
-  readonly "22019": "invalid_escape_character";
-  readonly "2200D": "invalid_escape_octet";
-  readonly "22025": "invalid_escape_sequence";
-  readonly "22P06": "nonstandard_use_of_escape_character";
-  readonly "22010": "invalid_indicator_parameter_value";
-  readonly "22023": "invalid_parameter_value";
-  readonly "22013": "invalid_preceding_or_following_size";
-  readonly "2201B": "invalid_regular_expression";
-  readonly "2201W": "invalid_row_count_in_limit_clause";
-  readonly "2201X": "invalid_row_count_in_result_offset_clause";
-  readonly "2202H": "invalid_tablesample_argument";
-  readonly "2202G": "invalid_tablesample_repeat";
-  readonly "22009": "invalid_time_zone_displacement_value";
-  readonly "2200C": "invalid_use_of_escape_character";
-  readonly "2200G": "most_specific_type_mismatch";
-  readonly "22004": "null_value_not_allowed";
-  readonly "22002": "null_value_no_indicator_parameter";
-  readonly "22003": "numeric_value_out_of_range";
-  readonly "2200H": "sequence_generator_limit_exceeded";
-  readonly "22026": "string_data_length_mismatch";
-  readonly "22001": "string_data_right_truncation";
-  readonly "22011": "substring_error";
-  readonly "22027": "trim_error";
-  readonly "22024": "unterminated_c_string";
-  readonly "2200F": "zero_length_character_string";
-  readonly "22P01": "floating_point_exception";
-  readonly "22P02": "invalid_text_representation";
-  readonly "22P03": "invalid_binary_representation";
-  readonly "22P04": "bad_copy_file_format";
-  readonly "22P05": "untranslatable_character";
-  readonly "2200L": "not_an_xml_document";
-  readonly "2200M": "invalid_xml_document";
-  readonly "2200N": "invalid_xml_content";
-  readonly "2200S": "invalid_xml_comment";
-  readonly "2200T": "invalid_xml_processing_instruction";
-  readonly "22030": "duplicate_json_object_key_value";
-  readonly "22031": "invalid_argument_for_sql_json_datetime_function";
-  readonly "22032": "invalid_json_text";
-  readonly "22033": "invalid_sql_json_subscript";
-  readonly "22034": "more_than_one_sql_json_item";
-  readonly "22035": "no_sql_json_item";
-  readonly "22036": "non_numeric_sql_json_item";
-  readonly "22037": "non_unique_keys_in_a_json_object";
-  readonly "22038": "singleton_sql_json_item_required";
-  readonly "22039": "sql_json_array_not_found";
-  readonly "2203A": "sql_json_member_not_found";
-  readonly "2203B": "sql_json_number_not_found";
-  readonly "2203C": "sql_json_object_not_found";
-  readonly "2203D": "too_many_json_array_elements";
-  readonly "2203E": "too_many_json_object_members";
-  readonly "2203F": "sql_json_scalar_required";
-  readonly "2203G": "sql_json_item_cannot_be_cast_to_target_type";
-  readonly "23000": "integrity_constraint_violation";
-  readonly "23001": "restrict_violation";
-  readonly "23502": "not_null_violation";
-  readonly "23503": "foreign_key_violation";
-  readonly "23505": "unique_violation";
-  readonly "23514": "check_violation";
-  readonly "23P01": "exclusion_violation";
-  readonly "24000": "invalid_cursor_state";
-  readonly "25000": "invalid_transaction_state";
-  readonly "25001": "active_sql_transaction";
-  readonly "25002": "branch_transaction_already_active";
-  readonly "25008": "held_cursor_requires_same_isolation_level";
-  readonly "25003": "inappropriate_access_mode_for_branch_transaction";
-  readonly "25004": "inappropriate_isolation_level_for_branch_transaction";
-  readonly "25005": "no_active_sql_transaction_for_branch_transaction";
-  readonly "25006": "read_only_sql_transaction";
-  readonly "25007": "schema_and_data_statement_mixing_not_supported";
-  readonly "25P01": "no_active_sql_transaction";
-  readonly "25P02": "in_failed_sql_transaction";
-  readonly "25P03": "idle_in_transaction_session_timeout";
-  readonly "25P04": "transaction_timeout";
-  readonly "26000": "invalid_sql_statement_name";
-  readonly "27000": "triggered_data_change_violation";
-  readonly "28000": "invalid_authorization_specification";
-  readonly "28P01": "invalid_password";
-  readonly "2B000": "dependent_privilege_descriptors_still_exist";
-  readonly "2BP01": "dependent_objects_still_exist";
-  readonly "2D000": "invalid_transaction_termination";
-  readonly "2F000": "sql_routine_exception";
-  readonly "2F005": "function_executed_no_return_statement";
-  readonly "2F002": "modifying_sql_data_not_permitted";
-  readonly "2F003": "prohibited_sql_statement_attempted";
-  readonly "2F004": "reading_sql_data_not_permitted";
-  readonly "34000": "invalid_cursor_name";
-  readonly "38000": "external_routine_exception";
-  readonly "38001": "containing_sql_not_permitted";
-  readonly "38002": "modifying_sql_data_not_permitted";
-  readonly "38003": "prohibited_sql_statement_attempted";
-  readonly "38004": "reading_sql_data_not_permitted";
-  readonly "39000": "external_routine_invocation_exception";
-  readonly "39001": "invalid_sqlstate_returned";
-  readonly "39004": "null_value_not_allowed";
-  readonly "39P01": "trigger_protocol_violated";
-  readonly "39P02": "srf_protocol_violated";
-  readonly "39P03": "event_trigger_protocol_violated";
-  readonly "3B000": "savepoint_exception";
-  readonly "3B001": "invalid_savepoint_specification";
-  readonly "3D000": "invalid_catalog_name";
-  readonly "3F000": "invalid_schema_name";
-  readonly "40000": "transaction_rollback";
-  readonly "40002": "transaction_integrity_constraint_violation";
-  readonly "40001": "serialization_failure";
-  readonly "40003": "statement_completion_unknown";
-  readonly "40P01": "deadlock_detected";
-  readonly "42000": "syntax_error_or_access_rule_violation";
-  readonly "42601": "syntax_error";
-  readonly "42501": "insufficient_privilege";
-  readonly "42846": "cannot_coerce";
-  readonly "42803": "grouping_error";
-  readonly "42P20": "windowing_error";
-  readonly "42P19": "invalid_recursion";
-  readonly "42830": "invalid_foreign_key";
-  readonly "42602": "invalid_name";
-  readonly "42622": "name_too_long";
-  readonly "42939": "reserved_name";
-  readonly "42804": "datatype_mismatch";
-  readonly "42P18": "indeterminate_datatype";
-  readonly "42P21": "collation_mismatch";
-  readonly "42P22": "indeterminate_collation";
-  readonly "42809": "wrong_object_type";
-  readonly "428C9": "generated_always";
-  readonly "42703": "undefined_column";
-  readonly "42883": "undefined_function";
-  readonly "42P01": "undefined_table";
-  readonly "42P02": "undefined_parameter";
-  readonly "42704": "undefined_object";
-  readonly "42701": "duplicate_column";
-  readonly "42P03": "duplicate_cursor";
-  readonly "42P04": "duplicate_database";
-  readonly "42723": "duplicate_function";
-  readonly "42P05": "duplicate_prepared_statement";
-  readonly "42P06": "duplicate_schema";
-  readonly "42P07": "duplicate_table";
-  readonly "42712": "duplicate_alias";
-  readonly "42710": "duplicate_object";
-  readonly "42702": "ambiguous_column";
-  readonly "42725": "ambiguous_function";
-  readonly "42P08": "ambiguous_parameter";
-  readonly "42P09": "ambiguous_alias";
-  readonly "42P10": "invalid_column_reference";
-  readonly "42611": "invalid_column_definition";
-  readonly "42P11": "invalid_cursor_definition";
-  readonly "42P12": "invalid_database_definition";
-  readonly "42P13": "invalid_function_definition";
-  readonly "42P14": "invalid_prepared_statement_definition";
-  readonly "42P15": "invalid_schema_definition";
-  readonly "42P16": "invalid_table_definition";
-  readonly "42P17": "invalid_object_definition";
-  readonly "44000": "with_check_option_violation";
-  readonly "53000": "insufficient_resources";
-  readonly "53100": "disk_full";
-  readonly "53200": "out_of_memory";
-  readonly "53300": "too_many_connections";
-  readonly "53400": "configuration_limit_exceeded";
-  readonly "54000": "program_limit_exceeded";
-  readonly "54001": "statement_too_complex";
-  readonly "54011": "too_many_columns";
-  readonly "54023": "too_many_arguments";
-  readonly "55000": "object_not_in_prerequisite_state";
-  readonly "55006": "object_in_use";
-  readonly "55P02": "cant_change_runtime_param";
-  readonly "55P03": "lock_not_available";
-  readonly "55P04": "unsafe_new_enum_value_usage";
-  readonly "57000": "operator_intervention";
-  readonly "57014": "query_canceled";
-  readonly "57P01": "admin_shutdown";
-  readonly "57P02": "crash_shutdown";
-  readonly "57P03": "cannot_connect_now";
-  readonly "57P04": "database_dropped";
-  readonly "57P05": "idle_session_timeout";
-  readonly "58000": "system_error";
-  readonly "58030": "io_error";
-  readonly "58P01": "undefined_file";
-  readonly "58P02": "duplicate_file";
-  readonly "58P03": "file_name_too_long";
-  readonly F0000: "config_file_error";
-  readonly F0001: "lock_file_exists";
-  readonly HV000: "fdw_error";
-  readonly HV005: "fdw_column_name_not_found";
-  readonly HV002: "fdw_dynamic_parameter_value_needed";
-  readonly HV010: "fdw_function_sequence_error";
-  readonly HV021: "fdw_inconsistent_descriptor_information";
-  readonly HV024: "fdw_invalid_attribute_value";
-  readonly HV007: "fdw_invalid_column_name";
-  readonly HV008: "fdw_invalid_column_number";
-  readonly HV004: "fdw_invalid_data_type";
-  readonly HV006: "fdw_invalid_data_type_descriptors";
-  readonly HV091: "fdw_invalid_descriptor_field_identifier";
-  readonly HV00B: "fdw_invalid_handle";
-  readonly HV00C: "fdw_invalid_option_index";
-  readonly HV00D: "fdw_invalid_option_name";
-  readonly HV090: "fdw_invalid_string_length_or_buffer_length";
-  readonly HV00A: "fdw_invalid_string_format";
-  readonly HV009: "fdw_invalid_use_of_null_pointer";
-  readonly HV014: "fdw_too_many_handles";
-  readonly HV001: "fdw_out_of_memory";
-  readonly HV00P: "fdw_no_schemas";
-  readonly HV00J: "fdw_option_name_not_found";
-  readonly HV00K: "fdw_reply_handle";
-  readonly HV00Q: "fdw_schema_not_found";
-  readonly HV00R: "fdw_table_not_found";
-  readonly HV00L: "fdw_unable_to_create_execution";
-  readonly HV00M: "fdw_unable_to_create_reply";
-  readonly HV00N: "fdw_unable_to_establish_connection";
-  readonly P0000: "plpgsql_error";
-  readonly P0001: "raise_exception";
-  readonly P0002: "no_data_found";
-  readonly P0003: "too_many_rows";
-  readonly P0004: "assert_failure";
-  readonly XX000: "internal_error";
-  readonly XX001: "data_corrupted";
-  readonly XX002: "index_corrupted";
-};
-type ConditionsByCode = typeof conditionsByCode;
-/** Name of a condition of PostgreSQL errors, such as `unique_violation`, or of a class of them, such as `integrity_constraint_violation`. */
-type QueryErrorCondition = ConditionsByCode[keyof ConditionsByCode];
-/**
- * SQLSTATE codes of each condition, with every code of its class for the condition of a class.
- *
- * TypeScript computes the map once, whereas a mapped type of the table for each condition would cost a check of another condition about 70 times as many instantiations.
- */
-type CodesByCondition = { [K in keyof ConditionsByCode as ConditionsByCode[K]]: K extends `${infer Class}000` ? `${Class}${string}` : K; };
-/** SQLSTATE codes of the condition `C`, with every code of its class for the condition of a class. */
-type QueryErrorCode<C extends QueryErrorCondition> = CodesByCondition[C];
-/**
- * Tells whether `error` is a `QueryError` of `condition`, including a `QueryError` of another copy of kern-orm.
- *
- * The condition of a class, such as `integrity_constraint_violation`, matches every error of its class, as in PL/pgSQL.
- */
-declare function isQueryError<C extends QueryErrorCondition>(error: unknown, condition: C): error is QueryError & {
-  readonly code: QueryErrorCode<C>;
-};
 /**
  * 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.
  *
@@ -3769,8 +2958,9 @@ type SqlTemplate<T, O extends OperatorDefinitions, I = T> = (strings: TemplateSt
 /**
  * Builds a SQL fragment.
  *
- * Interpolated expressions such as column references stay structured, a query of a table without clauses, such as `db.form`, becomes the name of the table, and other values become query parameters.
+ * Interpolated expressions such as column references stay structured, a query of a table without clauses, such as `db.form`, becomes the name of the table, a SQL fragment of `kern-orm/db` stays SQL, and other values become query parameters.
  * Another query of a table becomes a subquery in parentheses, and a query of one value, such as of an aggregate or of `exists`, its value, as in a condition.
+ * A parameter takes a string, a number, a bigint, a Boolean, `null` for `NULL`, a `Date`, or a `Uint8Array`: pass any other value, such as JSON or an array, with `param` and its type.
  * The type argument declares the TypeScript type of the fragment and does not convert values at runtime, so the fragment cannot be selected; the fragment has `isNull` and the operators of `equalityOperators` only.
  */
 declare function sql<T = unknown>(strings: TemplateStringsArray, ...values: unknown[]): UntypedExpression<T>;
@@ -3781,13 +2971,13 @@ declare function sql<T = unknown>(strings: TemplateStringsArray, ...values: unkn
  */
 declare function sql<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>): SqlTemplate<Output, O, Input>;
 /**
- * Creates a SQL fragment of a quoted name, such as of a table or a column known only at runtime, for the templates of `sql`, of `$query` and `$script` of a `Db`, and of `query` and `script` of a `Database`.
+ * Creates a SQL fragment of a quoted name, such as of a table or a column known only at runtime, for the templates of `sql`, and of `$query` and `$script` of a `Db`; `query` and `script` of a `Database` take `identifier` of `kern-orm/db`.
  *
  * Several names make a qualified name, such as `identifier(schema, table)` for `"schema"."table"`.
- * The fragment has no parameters, so a script takes it.
+ * The fragment has no parameters, so `$script` takes it.
  * The name is not qualified by the PostgreSQL schema of the statement.
  */
-declare function identifier(...names: [string, ...string[]]): UntypedExpression;
+declare function identifier$1(...names: [string, ...string[]]): UntypedExpression;
 /**
  * Creates an expression of a query parameter encoded with a type, for a value interpolated into `sql` or compared on its own.
  *
@@ -3806,4 +2996,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 { TestHooks as $, TypeOptions as $i, Ordering as $n, EqualityOperators as $r, MutationQueryState as $t, AnyExpression as A, Table as Ai, literal as An, PrimaryKeyValues as Ar, SchemaTables as At, DbOf as B, ResultMode as Bi, count as Bn, and as Br, DecodedFields as Bt, TextConversionSignature as C, AnyTableKeys as Ci, NestedQuery as Cn, SelectedOperandType as Cr, UsedRelation as Ct, textOperators as D, ColumnValues as Di, SelectionResult as Dn, KeyCheck as Dr, Schema as Dt, TextTypeOperators as E, ColumnShape as Ei, SelectionFieldTypes as En, GroupTerms as Er, AnySchema as Et, UntypedExpression as F, createTableFactory as Fi, GroupValue as Fn, WhereValues as Fr, RecordQueryState as Ft, TransactionOptions as G, SqlStatement as Gi, some as Gn, OneRow as Gr, AnyMutationQuery as Gt, Database as H, Connection as Hi, every as Hn, or as Hr, InitialSqlQueryState as Ht, AnyDb as I, defineTable as Ii, StringAggOptions as In, CombinedCondition as Ir, SelectionState as It, OpenedTestFixture as J, BaseType as Ji, OrderColumns as Jn, ResultByRows as Jr, ConflictTarget as Jt, createDatabase as K, createStatement as Ki, stringAgg as Kn, OneValueRows as Kr, ConflictActionRequired as Kt, BindOptions as L, NotFoundError as Li, UnfilteredAggregateOptions as Ln, Condition as Lr, AnyQuery as Lt, Expression as M, TableKeys as Mi, AggregateOptions as Mn, WhereCallback as Mr, defineSchema as Mt, ExpressionOperators as N, TableOptions as Ni, CountExpression as Nn, WhereCondition as Nr, AnyRecordQuery as Nt, NumberTypeOperators as O, KeyColumns as Oi, SelectionUses as On, NotAKey as Or, SchemaPart as Ot, TypedExpression as P, ToColumns as Pi, GroupAggregateExpression as Pn, WhereFilter as Pr, RecordQuery as Pt, TestHelpers as Q, TypeOperators as Qi, OrderTerms as Qn, EqualityOperator as Qr, MutationQuery as Qt, Db as R, RequiredRelationError as Ri, UnfilteredStringAggOptions as Rn, ConditionOperand as Rr, SelectQueryKind as Rt, PatternSignature as S, AnyTable as Si, MergeSelection as Sn, GroupedState as Sr, UsableRelation as St, TextOperators as T, ColumnOperators as Ti, Selection as Tn, GroupTerm as Tr, one as Tt, DatabaseOptions as U, Driver as Ui, max as Un, ExistsValueType as Ur, SqlQuery as Ut, DbQueryState as V, ResultRows as Vi, countDistinct as Vn, not as Vr, FieldTypes as Vt, IsolationLevel as W, DriverResult as Wi, min as Wn, FilteredRows as Wr, SqlQueryState as Wt, TestFixture as X, Type as Xi, OrderKey as Xn, CountValueType as Xr, InitialMutationState as Xt, PendingTestFixture as Y, TextValue as Yi, OrderDirection as Yn, ValueRows as Yr, InitialInsertState as Yt, TestFixtureOptions as Z, TypeInput as Zi, OrderTerm as Zn, CompileOptions as Zr, InsertMutationState as Zt, DriverErrorFields as _, QueryStateOf as _i, ExpressionValue as _n, UpdateValues as _r, RequiredMember as _t, sql as a, ColumnAttributes as aa, Operand as ai, CaseValue as an, QueryContext as ar, TransformedQuery as at, FALSE as b, SingletonQueryState as bi, GroupedField as bn, FoundQueryState as br, TableContext as bt, MatchResult as c, BoundOperators as ca, OperandUses as ci, TypedOperand as cn, BoundSelectQuery as cr, MergeRelations as ct, defineExpression as d, OperatorDefinitions as da, ValuesQuery as di, caseWhen as dn, SingletonInsertMany as dr, Relation as dt, TypeOutput as ea, HasEquality as ei, Helper as en, SelectedRefs as er, TestTransactionOptions as et, QueryErrorCode as f, GenericOperator as fa, EmptyRecord as fi, coalesce as fn, from as fr, RelationDeclaration as ft, ConnectionError as g, QueryState as gi, ExpressionInput as gn, UpdateSet as gr, RelationKind as gt, TransactionConnectionError as h, defineGenericOperator as ha, InitialQueryState as hi, ColumnFieldTypes as hn, InsertValues as hr, RelationKeys as ht, param as i, Column as ia, ComparisonSignature as ii, CaseCondition as in, ColumnRefs as ir, SynchronousResult as it, BaseOperators as j, TableFactoryOptions as ji, AggregateExpression as jn, EqValue as jr, Tables as jt, orderingOperators as k, Selectable as ki, Literal as kn, PrimaryKeyColumn as kr, SchemaPartRelations as kt, NotAColumn as l, MergeOperators as la, ScalarQuery as li, TypedOperandInput as ln, ResultOf as lr, NoRelations as lt, isQueryError as m, OperatorSignature as ma, Grouped as mi, least as mn, ConflictUpdateSet as mr, RelationKey as mt, SqlTemplate as n, defineType as na, equalityOperators as ni, defineHelper as nn, desc as nr, AnyTransformedQuery as nt, ColumnRefKey as o, KeyKind as oa, OperandValue as oi, FollowingOperand as on, RelationRefs as or, TransformedQueryState as ot, QueryErrorCondition as p, GenericOperatorImplementation as pa, FoundKey as pi, greatest as pn, ColumnValue as pr, RelationDeclarations as pt, TransactionCoordinator as q, AnyType as qi, sum as qn, QueryResult as qr, ConflictKeyRequired as qt, identifier as r, AnyColumn as ra, BooleanResult as ri, CaseBranch as rn, orderBy as rr, NotSynchronous as rt, MatchCheck as s, ToColumn as sa, compare as si, NullSkippingResult as sn, AnySelectQuery as sr, DeclaredRelations as st, toSnakeCase as t, TypeTransform as ta, InSignature as ti, HelperEffect as tn, asc as tr, createTestHelpers as tt, matches as u, NoOperators as ua, TypedScalarQuery as ui, TypedOperandOperators as un, SelectQuery as ur, OneRelationKeys as ut, QueryError as v, QueryValueType as vi, GroupOperandValue as vn, UpsertValues as vr, SchemaContext as vt, TextLengthSignature as w, ColumnDefinitions as wi, SelectedFieldTypes as wn, RowLockOptions as wr, many as wt, TRUE as x, TableQueryState as xi, GroupedRecord as xn, FoundState as xr, TableRelations as xt, toDriverError as y, SelectQueryState as yi, GroupSelectionResult as yn, FilteredStateRows as yr, SchemaRelations as yt, DbMutationState as z, ResultDecodeError as zi, avg as zn, Predicate as zr, AnySqlQuery as zt };
+export { matches as $, TypeInput as $i, UnfilteredAggregateOptions as $n, Condition as $r, Tables as $t, SqlQueryResult as A, QueryValueType as Ai, least as An, ConflictUpdateSet as Ar, MergeRelations as At, createDatabase as B, KeyColumns as Bi, SelectedFieldTypes as Bn, RowLockOptions as Br, SchemaContext as Bt, ResultByRows$1 as C, ValuesQuery as Ci, NullSkippingResult as Cn, AnySelectQuery as Cr, bindSchema as Ct, SessionOptions$1 as D, InitialQueryState as Di, caseWhen as Dn, SingletonInsertMany as Dr, TransformedQuery as Dt, ResultRows$1 as E, Grouped as Ei, TypedOperandOperators as En, SelectQuery as Er, SynchronousResult as Et, TransactionConnectionError as F, AnyTableKeys as Fi, GroupSelectionResult as Fn, FilteredStateRows as Fr, RelationDeclarations as Ft, SqlTemplate as G, TableOptions as Gi, Literal as Gn, PrimaryKeyColumn as Gr, UsedRelation as Gt, isQueryError as H, Table as Hi, SelectionFieldTypes as Hn, GroupTerms as Hr, TableContext as Ht, TransactionOptions$1 as I, ColumnDefinitions as Ii, GroupedField as In, FoundQueryState as Ir, RelationKey as It, sql as J, defineTable as Ji, AggregateOptions as Jn, WhereCallback as Jr, AnySchema as Jt, identifier$1 as K, ToColumns as Ki, literal as Kn, PrimaryKeyValues as Kr, many as Kt, TypeOptions$1 as L, ColumnOperators as Li, GroupedRecord as Ln, FoundState as Lr, RelationKeys as Lt, SqlStatement$1 as M, SingletonQueryState as Mi, ExpressionInput as Mn, UpdateSet as Mr, OneRelationKeys as Mt, SqlValue as N, TableQueryState as Ni, ExpressionValue as Nn, UpdateValues as Nr, Relation as Nt, SqlFragment$2 as O, QueryState as Oi, coalesce as On, from as Or, TransformedQueryState as Ot, TextValue as P, AnyTable as Pi, GroupOperandValue as Pn, UpsertValues as Pr, RelationDeclaration as Pt, NotAColumn as Q, Type as Qi, StringAggOptions as Qn, CombinedCondition as Qr, SchemaTables as Qt, TypeTransform$1 as R, ColumnShape as Ri, MergeSelection as Rn, GroupedState as Rr, RelationKind as Rt, QueryErrorCondition as S, TypedScalarQuery as Si, FollowingOperand as Sn, RelationRefs as Sr, DbQueryState as St, ResultMode$1 as T, FoundKey as Ti, TypedOperandInput as Tn, ResultOf as Tr, NotSynchronous as Tt, toDriverError as U, TableFactoryOptions as Ui, SelectionResult as Un, KeyCheck as Ur, TableRelations as Ut, createStatement$1 as V, Selectable as Vi, Selection as Vn, GroupTerm as Vr, SchemaRelations as Vt, toSnakeCase as W, TableKeys as Wi, SelectionUses as Wn, NotAKey as Wr, UsableRelation as Wt, MatchCheck as X, AnyType as Xi, GroupAggregateExpression as Xn, WhereFilter as Xr, SchemaPart as Xt, ColumnRefKey as Y, RequiredRelationError as Yi, CountExpression as Yn, WhereCondition as Yr, Schema as Yt, MatchResult as Z, BaseType as Zi, GroupValue as Zn, WhereValues as Zr, SchemaPartRelations as Zt, OneRow$1 as _, Operand as _i, HelperEffect as _n, asc as _r, AnyDb as _t, Database$1 as a, ColumnAttributes as aa, ExistsValueType as ai, AnyQuery as an, max as ar, TextLengthSignature as at, QueryError as b, OperandUses as bi, CaseCondition as bn, ColumnRefs as br, DbMutationState as bt, DerivableType$1 as c, BoundOperators as ca, CountValueType as ci, ConflictActionRequired as cn, stringAgg as cr, textOperators as ct, DriverErrorFields as d, OperatorDefinitions as da, EqualityOperators as di, InitialInsertState as dn, OrderDirection as dr, AnyExpression as dt, TypeOperators as ea, ConditionOperand as ei, defineSchema as en, UnfilteredStringAggOptions as er, defineExpression as et, DriverResult as f, GenericOperator as fa, HasEquality as fi, InitialMutationState as fn, OrderKey as fr, BaseOperators as ft, NotFoundError$1 as g, ComparisonSignature as gi, Helper as gn, SelectedRefs as gr, UntypedExpression as gt, IsolationLevel as h, defineGenericOperator as ha, BooleanResult as hi, MutationQueryState as hn, Ordering as hr, TypedExpression as ht, ConnectionError as i, Column as ia, or as ii, SelectionState as in, every as ir, TextConversionSignature as it, SqlQueryState as j, SelectQueryState as ji, ColumnFieldTypes as jn, InsertValues as jr, NoRelations as jt, SqlQuery$1 as k, QueryStateOf as ki, greatest as kn, ColumnValue as kr, DeclaredRelations as kt, DerivableTypeWithParameters as l, MergeOperators as la, CompileOptions as li, ConflictKeyRequired as ln, sum as lr, NumberTypeOperators as lt, InitialSqlQueryState$1 as m, OperatorSignature as ma, equalityOperators as mi, MutationQuery as mn, OrderTerms as mr, ExpressionOperators as mt, BaseDerivableType as n, defineType$1 as na, and as ni, RecordQuery as nn, count as nr, TRUE as nt, DatabaseOptions as o, KeyKind as oa, FilteredRows as oi, SelectQueryKind as on, min as or, TextOperators as ot, FieldTypes as p, GenericOperatorImplementation as pa, InSignature as pi, InsertMutationState as pn, OrderTerm as pr, Expression as pt, param as q, createTableFactory as qi, AggregateExpression as qn, EqValue as qr, one as qt, Connection as r, AnyColumn as ra, not as ri, RecordQueryState as rn, countDistinct as rr, PatternSignature as rt, DecodedFields as s, ToColumn as sa, QueryResult as si, AnyMutationQuery as sn, some as sr, TextTypeOperators as st, AnySqlQuery$1 as t, TypeOutput as ta, Predicate as ti, AnyRecordQuery as tn, avg as tr, FALSE as tt, Driver as u, NoOperators as ua, EqualityOperator as ui, ConflictTarget as un, OrderColumns as ur, orderingOperators as ut, OneValueRows$1 as v, OperandValue as vi, defineHelper as vn, desc as vr, BindOptions as vt, ResultDecodeError$1 as w, EmptyRecord as wi, TypedOperand as wn, BoundSelectQuery as wr, AnyTransformedQuery as wt, QueryErrorCode as x, ScalarQuery as xi, CaseValue as xn, QueryContext as xr, DbOf as xt, PollLockOptions$1 as y, compare as yi, CaseBranch as yn, orderBy as yr, Db as yt, ValueRows$1 as z, ColumnValues as zi, NestedQuery as zn, SelectedOperandType as zr, RequiredMember as zt };