kern-orm 0.2.0 → 0.4.0

package/dist/{expression-tYmWRuKR.d.mts → index--0tyG7sU.d.mts}

@@ -273,6 +273,11 @@ interface NestedField {
   readonly key: string;
   readonly nested: ResultPlan;
 }
+/** Field of a record in the template of a result plan: its key and its value before the values of a row are assigned. */
+interface RecordTemplateField {
+  readonly key: string;
+  readonly value: unknown;
+}
 /**
  * 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.
  *
@@ -292,6 +297,12 @@ interface ResultPlan extends ResultMode {
   readonly fields: readonly ResultField[];
   /** Required relation that guarantees the row of nested rows `one`, such as `field.form`, whose missing row is a `RequiredRelationError` rather than a `NotFoundError`. */
   readonly guaranteedBy?: string | undefined;
+  /**
+   * Every field of a record in its order, with the values of its literals, which a row does not hold; `undefined` for a query without literals.
+   *
+   * A record starts from it, so its keys keep their order whichever of them a row holds.
+   */
+  readonly recordTemplate?: readonly RecordTemplateField[] | 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 {
@@ -456,10 +467,12 @@ interface CompileOptions {
   /** PostgreSQL schema qualifying every table; tables stay unqualified when it is not set. */
   schemaName?: string;
 }
-/** Value compared with an expression of type `T` accepting values of type `I`; `null` is matched with `isNull` instead. */
-type Operand<T, I = T> = NonNullable<I> | AnyExpression<NonNullable<T> | null>;
-/** SQL value of an operand, unwrapping an expression. */
-type OperandValue<V> = V extends AnyExpression<infer T> ? T : V;
+/**
+ * Value compared with an expression of type `T` accepting values of type `I`: a value, an expression, or a query of one value, such as of `get` or of an aggregate; `null` is matched with `isNull` instead.
+ */
+type Operand<T, I = T> = NonNullable<I> | AnyExpression<NonNullable<T> | null> | ScalarQuery<NonNullable<T> | null>;
+/** SQL value of an operand, unwrapping an expression or a query. */
+type OperandValue<V> = V extends AnyExpression<infer T> ? T : V extends ScalarQuery ? ScalarQueryValue<V> : V;
 /** Boolean result that can be NULL when an input value can be NULL. */
 type BooleanResult<T> = boolean | (null extends T ? null : never);
 /** Signature of a generic operator comparing an expression with an operand of its type, such as `lt`. */
@@ -467,56 +480,80 @@ interface ComparisonSignature extends OperatorSignature {
   readonly method: <V extends Operand<this["T"], this["I"]>>(value: V) => Expression<BooleanResult<this["T"] | OperandValue<V>>>;
 }
 /**
- * Compares an expression with a value or another expression, encoding a plain value with the type of the expression.
+ * Compares an expression with a value, another expression, or a query of one value, encoding a plain value with the type of the expression.
  *
  * Operators of custom types build comparisons with it, such as `compare(self, "ILIKE", pattern)`.
  */
 declare function compare<T, V>(self: AnyExpression<T>, operator: ComparisonNode["operator"], value: V): Expression<BooleanResult<T | OperandValue<V>>>;
-/** Runtime mark of the operators of `equalityOperators`, which tell that a type has SQL `=`. */
-declare const equalityBrand: unique symbol;
-/** Generic operator of `equalityOperators`, which gives the type it is added to SQL `=`. */
-interface EqualityOperator<S extends OperatorSignature> extends GenericOperator<S> {
-  readonly [equalityBrand]: true;
+/** Selection of the rows of a nested query as the value of the field `key`. */
+interface NestedSelectionNode {
+  readonly key: string;
+  readonly query: QueryNode;
+  /** `Db` that the nested query is bound to, which must be the `Db` that runs the statement. */
+  readonly db: AnyDb | undefined;
 }
-/** Signature of `in`: membership in a list of operands of the expression type; an empty list yields `FALSE`. */
-interface InSignature extends OperatorSignature {
-  readonly method: <const L extends readonly Operand<this["T"], this["I"]>[]>(list: L) => Expression<L extends readonly [] ? boolean : BooleanResult<this["T"] | OperandValue<L[number]>>>;
+/** Selection of a value from code as the field `key` of every record, which a statement does not select. */
+interface LiteralSelectionNode {
+  readonly key: string;
+  readonly literal: unknown;
+}
+/** Field that a statement selects: an expression, or the rows of a nested query. */
+type SqlSelectedNode = ProjectionNode | NestedSelectionNode;
+/** Field selected by a query: one that its statement selects, or a literal. */
+type SelectedNode = SqlSelectedNode | LiteralSelectionNode;
+/** Select query of a table; its result mode applies when it is executed or its rows are nested. */
+interface QueryNode extends ResultMode {
+  readonly kind: "query";
+  readonly from: TableSourceNode;
+  /** Relation whose records the query selects, correlated with its parent by the relation filter. */
+  readonly relation: RelationDefinition | undefined;
+  /** Fields in the order of the result, with unique keys; a query without them returns records without fields. */
+  readonly projections: readonly SelectedNode[];
+  readonly filters: QueryFilters;
+  readonly orderBy: readonly OrderNode[];
+  readonly limit: ExpressionNode | undefined;
+  readonly offset: ExpressionNode | undefined;
+  /** Whether a required relation guarantees the row of the query, so that a filter makes a query of rows `one` resolve without it; see `SelectQueryState`. */
+  readonly guaranteed: boolean;
+  /** Whether `all` allows a mutation of the query to change every row of the table without a filter. */
+  readonly all: boolean;
 }
-/** Operators of `equalityOperators`. */
-type EqualityOperators = {
-  eq: EqualityOperator<ComparisonSignature>;
-  ne: EqualityOperator<ComparisonSignature>;
-  in: EqualityOperator<InSignature>;
-};
-/** Tells whether operators `O` include an operator of `equalityOperators`, so that their type has SQL `=`. */
-type HasEquality<O> = true extends { [K in keyof O]: O[K] extends {
-  readonly [equalityBrand]: true;
-} ? true : false; }[keyof O] ? true : false;
 /**
- * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+ * 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.
  *
- * A type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
+ * Its result mode is the rows mode of the rows it changes and whether a row is the value of its only field.
  */
-declare const equalityOperators: EqualityOperators;
+type MutationNode = MutationStatementNode<SelectedNode>;
+/** Query of `$select` without a source: one record whose fields are the values of expressions, the rows of independent queries, and literals. */
+interface RecordQueryNode {
+  readonly kind: "record";
+  /** Fields in the order of the record, with unique keys. */
+  readonly projections: readonly SelectedNode[];
+}
 /** Records of a query without selected fields. */
 type EmptyRecord = Record<never, never>;
 /** State of a query in types: the record or value of its rows, how its rows become its result, and the relations it selects records of. */
 interface QueryState extends ResultMode {
-  /** Record of a row, or the value of its only field for a query made by `get`, `pluck`, or an aggregate method, such as `count`. */
+  /** Record of a row, or the value of its only field for a query made by `get`, `pluck`, an aggregate method, such as `count`, or `exists`. */
   readonly result: unknown;
   /** Relations whose records the query and the queries nested in it select, which a `Db` must have. */
   readonly uses: UsedRelation;
 }
+/** Type of the value of a query: the values that it encodes, such as the fallback of `coalesce`, and its operators, which `expr` gives its expression. */
+interface QueryValueType {
+  readonly input: unknown;
+  readonly operators: OperatorDefinitions;
+}
 /**
- * State of a select query in types: its table, the relations of its schema, the record or value of its rows and the values that its value accepts, how its rows become its result, and the relations it selects records of.
+ * State of a select query in types: its table, the relations of its schema, the record or value of its rows and the type of its value, how its rows become its result, and the relations it selects records of.
  *
  * Methods change only their own parts of the state.
  */
 interface SelectQueryState extends QueryState {
   readonly table: AnyTable;
   readonly schema: SchemaContext;
-  /** Values that the type of the value of a query of values encodes, such as the fallback of `coalesce`; `never` for a query of records. */
-  readonly input: unknown;
+  /** Type of the value of a query of values, a `QueryValueType`; `never` for a query of records. */
+  readonly valueType: unknown;
   /**
    * Whether a required relation guarantees the row of the query, such as of `field.form`.
    *
@@ -524,7 +561,7 @@ interface SelectQueryState extends QueryState {
    * The callback of a helper starts with it, so that the effect of the helper records whether the callback filters.
    */
   readonly guaranteed: boolean;
-  /** Whether the query is made by an aggregate method, such as `count`, which makes `get`, `pluck`, and the aggregate methods reject it. */
+  /** Whether the query is made by an aggregate method, such as `count`, or by `exists`, which makes `get`, `pluck`, the aggregate methods, and `exists` reject it. */
   readonly aggregate: boolean;
 }
 /** State of a query over table `T` with schema context `C`, whatever its result. */
@@ -539,50 +576,27 @@ interface QueryStateOf<T extends AnyTable, C extends SchemaContext = SchemaConte
  */
 interface InitialQueryState<T extends AnyTable, C extends SchemaContext = NoRelations, U extends UsedRelation = never, Rows extends ResultRows = "many", Guaranteed extends boolean = false> extends QueryStateOf<T, C> {
   readonly result: EmptyRecord;
-  readonly input: never;
+  readonly valueType: never;
   readonly rows: Rows;
   readonly value: false;
   readonly uses: U;
   readonly guaranteed: Guaranteed;
   readonly aggregate: false;
 }
-/** Selection of the rows of a nested query as the value of the field `key`. */
-interface NestedSelectionNode {
-  readonly key: string;
-  readonly query: QueryNode;
-  /** `Db` that the nested query is bound to, which must be the `Db` that runs the statement. */
-  readonly db: AnyDb | undefined;
-}
-/** Field selected by a query: an expression, or the rows of a nested query. */
-type SelectedNode = ProjectionNode | NestedSelectionNode;
-/** Select query of a table; its result mode applies when it is executed or its rows are nested. */
-interface QueryNode extends ResultMode {
-  readonly kind: "query";
-  readonly from: TableSourceNode;
-  /** Relation whose records the query selects, correlated with its parent by the relation filter. */
-  readonly relation: RelationDefinition | undefined;
-  /** Fields in the order of the result, with unique keys; a query without them returns records without fields. */
-  readonly projections: readonly SelectedNode[];
-  readonly filters: QueryFilters;
-  readonly orderBy: readonly OrderNode[];
-  readonly limit: ExpressionNode | undefined;
-  readonly offset: ExpressionNode | undefined;
-  /** Whether a required relation guarantees the row of the query, so that a filter makes a query of rows `one` resolve without it; see `SelectQueryState`. */
-  readonly guaranteed: boolean;
-  /** Whether `all` allows a mutation of the query to change every row of the table without a filter. */
-  readonly all: boolean;
-}
-/**
- * Mutation of a table that returns the fields of the rows it changes, which may nest queries, or the number of the rows without them.
- *
- * Its result mode is the rows mode of the rows it changes and whether a row is the value of its only field.
- */
-type MutationNode = MutationStatementNode<SelectedNode>;
-/** Query of `$select` without a source: one record whose fields are the values of expressions and the rows of independent queries. */
-interface RecordQueryNode {
-  readonly kind: "record";
-  /** Fields in the order of the record, with unique keys. */
-  readonly projections: readonly SelectedNode[];
+/** Type of a count: a `bigint` of PostgreSQL decoded as a number, rejecting a count that a number cannot hold exactly. */
+declare const countType: BaseType<number, number, MergeOperators<NoOperators, {
+  lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
+}>, undefined>;
+/** Type of the value of a query of a count. */
+interface CountValueType extends QueryValueType {
+  readonly input: TypeInput<typeof countType>;
+  readonly operators: TypeOperators<typeof countType>;
 }
 /** Rows mode of a query of a relation of kind `Kind`: `many`, or one row, `nullable` unless `Required` is `true`; a union gives the union of their modes. */
 type RelationRows<Kind extends RelationKind, Required extends boolean> = Kind extends "many" ? "many" : Required extends true ? "one" : "nullable";
@@ -605,7 +619,7 @@ type ResultByRows<Result, Rows extends ResultRows> = Rows extends "many" ? Resul
 /** References to the columns of the query source, passed to query callbacks. */
 type ColumnRefs<T extends AnyTable> = { readonly [K in keyof T["columns"]]: Expression<Selectable<T>[K], ColumnOperators<T, K>, ColumnValues<T>[K]>; };
 /**
- * Queries of the records of the relations of the table of schema context `C`, by relation name, which the callback of `select` receives beside the columns.
+ * Queries of the records of the relations of the table of schema context `C`, by relation name, which the callbacks of `select`, `where`, and `orderBy` receive beside the columns.
  *
  * A relation name is never a column key of its table.
  * A context whose table key is not known, such as one of a query of any schema, has no relations.
@@ -616,9 +630,14 @@ type RelationQueries<R extends SchemaContext["relations"], K extends keyof R & s
 type RelatedQuery<R extends SchemaContext["relations"], K extends keyof R & string, N extends keyof R[K] & string> = SelectQuery<InitialQueryState<R[K][N]["target"], TableContext<R, R[K][N]["targetKey"]>, UsedRelation<K, N, R[K][N]>, RelationRows<R[K][N]["kind"], R[K][N]["required"]>, R[K][N]["required"]>>;
 /** Runtime context of the queries of a table in the schema they start from. */
 interface QueryContext {
-  /** Getters of the queries of the relations of the table, which the references of `select` have as their own properties and which read the key columns from them. */
+  /** Getters of the queries of the relations of the table, which the references of the callbacks of `select`, `where`, and `orderBy` have as their own properties and which read the key columns from them. */
   readonly relations: PropertyDescriptorMap;
 }
+/** Type of the value of a query of `exists`. */
+interface ExistsValueType extends QueryValueType {
+  readonly input: boolean;
+  readonly operators: EqualityOperators;
+}
 declare const conditionValues: unique symbol;
 /** Predicate accepted by `where`, `and`, `or`, and `not`; SQL treats a `NULL` predicate as not satisfied. */
 type Predicate = AnyExpression<boolean | null>;
@@ -631,11 +650,11 @@ interface Condition<V> {
   readonly [conditionValues]?: V;
 }
 /**
- * Operand of `and`, `or`, and `not`: a predicate, a condition, or an object of column values.
+ * Operand of `and`, `or`, and `not`: a predicate, a query of one Boolean value, such as of `exists`, a condition, or an object of column values.
  *
  * Column values `V` are never inferred from an object, so that object keys are checked against the table instead of determining `V`.
  */
-type ConditionOperand<V, T extends boolean | null = boolean | null> = AnyExpression<T> | Condition<V> | NoInfer<V>;
+type ConditionOperand<V, T extends boolean | null = boolean | null> = AnyExpression<T> | ScalarQuery<T> | Condition<V> | NoInfer<V>;
 /**
  * Result of `and`, `or`, and `not`: a condition checked against the table inside `where`, a Boolean expression without a table.
  */
@@ -653,29 +672,34 @@ declare function not<V = never, T extends boolean | null = [V] extends [never] ?
  */
 type WhereValues<T extends AnyTable> = { [K in keyof T["columns"]]?: EqValue<T, K> | (null extends ColumnValues<T>[K] ? null : never); };
 /** Operand of the `eq` operator of column `K` of table `T` in an object passed to `where`, such as an expression. */
-type EqValue<T extends AnyTable, K extends keyof T["columns"]> = IsAny<ColumnOperators<T, K>> extends true ? ColumnValues<T>[K] : EqOperand<ColumnRefs<T>[K]>;
-/** Operand of the `eq` operator of an expression, if it has one taking a single operand. */
+type EqValue<T extends AnyTable, K extends keyof T["columns"]> = IsAny<ColumnOperators<T, K>> extends true ? ColumnValues<T>[K] : ColumnOperators<T, K> extends {
+  readonly eq: EqualityOperator<ComparisonSignature>;
+} ? Operand<TypeOutput<T["columns"][K]["type"]>, TypeInput<T["columns"][K]["type"]>> : EqOperand<ColumnRefs<T>[K]>;
+/** Operand of the `eq` operator of an expression, if it has one taking a single operand and returning a predicate. */
 type EqOperand<E> = E extends {
   eq: (value: infer V) => Predicate;
 } ? V : never;
-/** Filter of `where`: a Boolean expression, an object of column values, or their combination with `and`, `or`, and `not`. */
+/** Filter of `where`: a Boolean expression, a query of one Boolean value, such as of `exists`, an object of column values, or their combination with `and`, `or`, and `not`. */
 type WhereCondition<T extends AnyTable> = ConditionOperand<WhereValues<T>>;
-/** Argument of `where`: a condition, or a callback that receives the columns of the query and returns one. */
-type WhereFilter<T extends AnyTable> = WhereCondition<T> | ((columns: ColumnRefs<T>) => WhereCondition<T>);
+/** Callback of `where` over table `T` with schema context `C`: it receives the columns and the queries of the relations of the table and returns a condition. */
+type WhereCallback<T extends AnyTable, C extends SchemaContext = NoRelations> = (columns: ColumnRefs<T> & RelationRefs<C>) => WhereCondition<T>;
+/** Argument of `where` of a query over table `T` with schema context `C`: a condition, or a callback that receives the columns and the relations of the query and returns one. */
+type WhereFilter<T extends AnyTable, C extends SchemaContext = NoRelations> = WhereCondition<T> | WhereCallback<T, C>;
 /**
  * Defines a reusable condition of `where` for queries over a table, checking its objects of column values against the columns.
  *
  * The condition can be combined further with `and`, `or`, and `not`.
  */
-declare function defineFilter<T extends AnyTable>(table: TableOrQuery<T>, filter: NoInfer<WhereCondition<T>>): WhereCondition<T>;
+declare function defineFilter<T extends AnyTable, C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, filter: NoInfer<WhereCondition<T>>): WhereCondition<T>;
 /**
  * Defines a reusable callback of `where` for queries over a table, checking its objects of column values against the columns.
  *
- * Another callback can call it with its columns.
+ * Defined with a query of a schema or a `Db`, such as `schema.form`, it receives the queries of the relations of the table in that schema, and applies to queries whose schema has them.
+ * Another callback of `where` can call it with the columns and the relations it receives.
  */
-declare function defineFilter<T extends AnyTable>(table: TableOrQuery<T>, filter: NoInfer<(columns: ColumnRefs<T>) => WhereCondition<T>>): (columns: ColumnRefs<T>) => WhereCondition<T>;
+declare function defineFilter<T extends AnyTable, C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, filter: NoInfer<WhereCallback<T, C>>): WhereCallback<T, C>;
 /** Defines a reusable filter of `where` for queries over a table, either a condition or a callback. */
-declare function defineFilter<T extends AnyTable>(table: TableOrQuery<T>, filter: NoInfer<WhereFilter<T>>): WhereFilter<T>;
+declare function defineFilter<T extends AnyTable, C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, filter: NoInfer<WhereFilter<T, C>>): WhereFilter<T, C>;
 /**
  * Values of the primary key of table `T` that `find` takes, in the order of its columns, or `never` where the type of `T` tells no primary key.
  *
@@ -703,26 +727,77 @@ type OrderColumns<T extends AnyTable> = { readonly [K in keyof T["columns"]]?: O
 /** Argument of `orderBy` of a query over table `T`: a column key, sorted in ascending order, or columns with directions. */
 type OrderKey<T extends AnyTable> = (keyof T["columns"] & string) | OrderColumns<T>;
 declare const ordering: unique symbol;
-/** Expression with the direction of its sort key, made by `asc`, `desc`, or `orderBy`. */
+/** Expression or query of one value with the direction of its sort key, made by `asc`, `desc`, or `orderBy`. */
 interface Ordering {
   readonly [ordering]: true;
 }
-/** Sort key returned by the callback of `orderBy`: an expression, sorted in ascending order, or an expression with a direction. */
-type OrderTerm = AnyExpression | Ordering;
+/** Sort key returned by the callback of `orderBy`: an expression or a query of one value, such as of an aggregate of related records, sorted in ascending order, or one with a direction. */
+type OrderTerm = AnyExpression | ScalarQuery | Ordering;
 /**
  * References of the callback of `orderBy` to the fields of records `R` selected by a query: their expressions by key.
  *
- * A field of a nested query, such as of nested rows or of an aggregate, is among them in types, but reading it throws.
+ * A field of nested rows or of a literal is among them in types, but reading it throws; a field of an aggregate or of `exists` sorts by its value.
  */
 type SelectedRefs<R> = { readonly [K in keyof R & string]: AnyExpression<R[K]>; };
 /** Sort keys returned by the callback of `orderBy`: one or an array of them. */
 type OrderTerms = OrderTerm | readonly OrderTerm[];
-/** Sorts by `expression` in ascending order, in the callback of `orderBy`. */
-declare function asc(expression: AnyExpression): Ordering;
-/** Sorts by `expression` in descending order, in the callback of `orderBy`. */
-declare function desc(expression: AnyExpression): Ordering;
-/** Sorts by `expression` in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
-declare function orderBy(expression: AnyExpression, direction: OrderDirection): Ordering;
+/** Sorts by `value`, an expression or a query of one value, in ascending order, in the callback of `orderBy`. */
+declare function asc(value: AnyExpression | ScalarQuery): Ordering;
+/** Sorts by `value`, an expression or a query of one value, in descending order, in the callback of `orderBy`. */
+declare function desc(value: AnyExpression | ScalarQuery): Ordering;
+/** Sorts by `value`, an expression or a query of one value, in `direction`, such as `"desc nulls last"`, in the callback of `orderBy`. */
+declare function orderBy(value: AnyExpression | ScalarQuery, direction: OrderDirection): Ordering;
+/**
+ * Field of a selection whose value is `T`, made by `literal`.
+ *
+ * It is not an expression: it has no SQL, so only a selection takes it.
+ */
+declare class Literal<out T> {
+  /** Value of the field in every record, which the query returns as it is. */
+  readonly literal: T;
+  constructor(
+  /** Value of the field in every record, which the query returns as it is. */
+  literal: T);
+  /** Rejects the literal as an operand of an expression: a statement has no SQL of it. */
+  [operandNode](): never;
+}
+/**
+ * Creates a field of a selection with `value` in every record, without selecting anything in SQL: the query returns the value itself, not a copy of it, whatever it is.
+ *
+ * It lets a branch of a selection skip a column or a nested query, such as `withHint ? field.hint : literal(null)`.
+ * To use a value in SQL, such as in a condition, pass it through `param` instead.
+ */
+declare function literal<T extends {} | null | undefined>(value: T): Literal<T>;
+/** Expressions, nested queries, and literals selected under the keys of the result fields; a record has no symbol keys. */
+interface Selection {
+  readonly [key: string]: TypedExpression | NestedQuery | Literal<unknown>;
+  readonly [key: symbol]: never;
+}
+/** Query whose rows a selection nests as the value of a field: a query of any state and kind, such as a query of a relation. */
+type NestedQuery = QueryOf<SelectQueryState>;
+/** Record of the values of the expressions, of the nested rows, and of the literals of a selection. */
+type SelectionResult<S extends Selection> = { [K in keyof S]: FieldValue<S[K]>; };
+/** Value of a selected field: of an expression, of the nested rows of a query as the result of executing it, or of a literal, for each member of a union of them. */
+type FieldValue<V> = V extends NestedQuery ? QueryResult<V["types"]> : V extends Literal<infer T> ? T : ExpressionValue<V>;
+/** Relations whose records the nested queries of a selection select. */
+type SelectionUses<S extends Selection> = S[keyof S] extends (infer V) ? V extends NestedQuery ? V["types"]["uses"] : never : never;
+/** Value of a selected expression. */
+type ExpressionValue<E> = E extends AnyExpression<infer T> ? T : never;
+/** Values that the type of an expression encodes, such as in place of its value. */
+type ExpressionInput<E> = E extends AnyExpression<unknown, infer I> ? I : never;
+declare const helperFields: unique symbol;
+/** Marker of the input fields of a helper, carrying the keys selected by its callback. */
+interface HelperFields<Keys extends PropertyKey = PropertyKey> {
+  readonly [helperFields]: Keys;
+}
+/** Records with `Fields` added or replaced, for each branch of either record type; `any` stays `any`. */
+type MergeSelection<Previous, Fields> = Previous extends unknown ? Fields extends unknown ? MergeFields<RecordFields<Previous>, RecordFields<Fields>> & (IsAny<Previous> extends true ? Previous : unknown) : never : never;
+/** Fields with numeric keys represented as the string keys used in result records. */
+type RecordFields<Fields> = Fields extends unknown ? [Extract<keyof Fields, number>] extends [never] ? Fields : { [K in keyof Fields as K extends number ? `${K}` : K]: Fields[K]; } : never;
+/** Merge of normalized fields, retaining the previous value when an optional replacement is absent. */
+type MergeFields<Previous, Fields> = Simplify<{ [K in keyof Previous as K extends keyof Fields ? ({} extends Pick<Fields, K> ? K : never) : K]: K extends typeof helperFields // A branch selecting extra keys must not be reduced to one selecting fewer fields or none.
+ ? Previous[K] | keyof Fields : K extends keyof Fields // A decoder can return undefined, so it cannot be excluded as merely an absent property.
+ ? Previous[K] | Fields[K] : Previous[K]; } & { [K in keyof Fields as K extends keyof Previous ? ({} extends Pick<Fields, K> ? never : K) : K]: Fields[K]; }>;
 /** Value of column `K` of table `T` that an insert or an update sets: a value that its type encodes, `null` for a nullable column, or an expression of its values. */
 type ColumnValue<T extends AnyTable, K extends keyof T["columns"]> = ColumnValues<T>[K] | AnyExpression<Selectable<T>[K]>;
 /** Key of a column of table `T` that an insert may omit, which gets its default: one that the database gives a value, as `hasDefault` marks it, or a nullable one, whose default is `NULL` unless the database declares another. */
@@ -749,6 +824,47 @@ type FoundState<S extends SelectQueryState> = ChangeState<S, {
 }>;
 /** Query of state `S`, bound or unbound. */
 type QueryOf<S extends SelectQueryState> = SelectQuery<S, SelectQueryKind>;
+declare const scalarValue: unique symbol;
+/** Value of a query of state `S` in an expression: its value, or `NULL` without its row unless the query always has it. */
+type ScalarValue<S extends SelectQueryState> = S["aggregate"] extends true ? S["result"] : S["guaranteed"] extends true ? S["result"] : S["result"] | null;
+/**
+ * Query of one value of a table, such as of `get`, of an aggregate, or of `exists`, which an expression takes as a scalar subquery of its value, or as `EXISTS` of the rows of a query of `exists`.
+ *
+ * `T` is its value there: without its row, a query of `get` is `NULL`, unless a required relation guarantees the row, such as of `field.form`.
+ */
+interface ScalarQuery<T = unknown> {
+  /** Value of the query in an expression, from which an expression infers `T`. */
+  readonly [scalarValue]: T;
+  readonly types: ScalarQueryState;
+  readonly exists: unknown;
+}
+/** Value of query `Q` of one value in an expression. */
+type ScalarQueryValue<Q extends ScalarQuery> = Q[typeof scalarValue];
+/** State of a query of one value, which an expression takes. */
+interface ScalarQueryState extends SelectQueryState {
+  readonly rows: "one" | "optional";
+  readonly value: true;
+}
+/** State of a query of one value with the type of its value, whose expression `expr` gives. */
+interface ExpressionQueryState extends ScalarQueryState {
+  readonly valueType: QueryValueType;
+}
+/** Query of one value of a table with the type of its value, such as of `get` or of an aggregate, which gives the expression of a function the decoding and the operators of its value. */
+interface TypedScalarQuery extends ScalarQuery {
+  readonly types: ExpressionQueryState;
+}
+/** Query of values of a table of any rows, such as of `pluck`, whose value is `T`, which `in` takes as a subquery of its values. */
+interface ValuesQuery<T = unknown> {
+  readonly types: ValuesQueryState<T>;
+  readonly exists: unknown;
+}
+/** Value of query `Q` of values, of each of its rows. */
+type ValuesQueryValue<Q extends ValuesQuery> = Q["types"]["result"];
+/** State of a query of values whose value is `T`. */
+interface ValuesQueryState<T> extends SelectQueryState {
+  readonly result: T;
+  readonly value: true;
+}
 /** State of a query whose rows are records, which `select` and `clearSelect` change. */
 type RecordQueryState$1 = SelectQueryState & {
   readonly value: false;
@@ -757,25 +873,47 @@ type RecordQueryState$1 = SelectQueryState & {
 type UnguaranteedQueryState = SelectQueryState & {
   readonly guaranteed: false;
 };
-/** State of a query whose rows are values, made by `get`, `pluck`, or an aggregate method, such as `count`. */
+/** State of a query whose rows are values, made by `get`, `pluck`, an aggregate method, such as `count`, or `exists`. */
 type ValueQueryState = SelectQueryState & {
   readonly value: true;
 };
-/** State of a query not made by an aggregate method, which `get`, `pluck`, and the aggregate methods apply to. */
+/** State of a query of values with the values that the type of its value encodes, which `coalesce` takes; it narrows nothing else, so that a call compares no operators. */
+type CoalesceQueryState = ValueQueryState & {
+  readonly valueType: {
+    readonly input: unknown;
+  };
+};
+/** State of a query not made by an aggregate method or `exists`, which `get`, `pluck`, the aggregate methods, and `exists` apply to. */
 type UnaggregatedQueryState = SelectQueryState & {
   readonly aggregate: false;
 };
-/** State of a query of the value `V` of an aggregate over the rows of a query of state `S`, which always returns one row, accepting values `I` in place of its value. */
-type AggregateState<S extends SelectQueryState, V, I> = ChangeState<S, {
+/** Type of the value of a query of column `K` of table `T`. */
+type ColumnValueType<T extends AnyTable, K extends keyof T["columns"]> = {
+  readonly input: ColumnValues<T>[K];
+  readonly operators: ColumnOperators<T, K>;
+};
+/** Type of the value of a query of expression `E`. */
+type ExpressionValueType<E extends TypedExpression> = {
+  readonly input: ExpressionInput<E>;
+  readonly operators: ExpressionOperators<E>;
+};
+/** State of a query of the value `V` of type `Type` of an aggregate or of `exists` over the rows of a query of state `S`, which always returns one row. */
+type AggregateState<S extends SelectQueryState, V, Type extends QueryValueType> = ChangeState<S, {
   result: V;
-  input: I;
+  valueType: Type;
   rows: "one";
   value: true;
   guaranteed: false;
   aggregate: true;
 }>;
+/** State of a query of the number of rows or of values among the rows of a query of state `S`. */
+type CountState<S extends SelectQueryState> = AggregateState<S, number, CountValueType>;
+/** State of a query of an aggregate of the values of column `K` of the rows of a query of state `S`, `NULL` without values other than `NULL`. */
+type ColumnAggregateState<S extends SelectQueryState, K extends keyof S["table"]["columns"]> = AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValueType<S["table"], K>>;
+/** State of a query of an aggregate of the values of expression `E` over the rows of a query of state `S`, `NULL` without values other than `NULL`. */
+type ExpressionAggregateState<S extends SelectQueryState, E extends TypedExpression> = AggregateState<S, ExpressionValue<E> | null, ExpressionValueType<E>>;
 /** Value `V` of a query of values whose `NULL` `coalesce` replaces with fallback `F`. */
-type CoalescedValue<V, F> = Exclude<V, null> | (F extends AnyExpression<infer T> ? Extract<T, null> : never);
+type CoalescedValue<V, F> = Exclude<V, null> | Extract<OperandValue<F>, null>;
 /** State of a query of many rows, which `limit` and `offset` apply to. */
 type ManyRowsQueryState = SelectQueryState & {
   readonly rows: "many";
@@ -801,6 +939,8 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
   readonly context: QueryContext;
   readonly types: S;
+  /** Value of the query in an expression, for types only. */
+  readonly [scalarValue]: ScalarValue<S>;
   /** `Db` that executes the query when it is awaited; `undefined` for an unbound query. */
   readonly db: QueryDb<Kind>;
   /** Executes a bound query on its `Db`; `undefined` for an unbound query, so that it is not thenable. */
@@ -808,14 +948,14 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   constructor(table: S["table"], node: QueryNode,
   /** Relations of the table in the schema the query starts from, which `select` gives its callback. */
   context: QueryContext, db?: AnyDb);
-  /** Adds a filter combined with `AND` with the previous ones. */
-  where<Q extends QueryOf<UnguaranteedQueryState>>(this: Q, filter: WhereFilter<Q["types"]["table"]>): Q;
+  /** Adds a filter combined with `AND` with the previous ones; a callback receives the columns and the queries of the relations of the table. */
+  where<Q extends QueryOf<UnguaranteedQueryState>>(this: Q, filter: WhereFilter<Q["types"]["table"], Q["types"]["schema"]>): Q;
   /**
-   * Adds a filter combined with `AND` with the previous ones.
+   * Adds a filter combined with `AND` with the previous ones; a callback receives the columns and the queries of the relations of the table.
    *
    * A query of the record of a required relation, such as `field.form`, resolves to `null` without a record that passes the filter, or to `undefined` after `get` or `pluck`.
    */
-  where<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, filter: WhereFilter<S["table"]>): SelectQuery<FilteredState<S>, Kind>;
+  where<S extends SelectQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, filter: WhereFilter<S["table"], S["schema"]>): SelectQuery<FilteredState<S>, Kind>;
   /** Selects all columns of the table, replacing fields under their keys. */
   select<S extends RecordQueryState$1, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>, all: "*"): SelectQuery<ChangeState<S, {
     result: MergeSelection<S["result"], Selectable<S["table"]>>;
@@ -871,7 +1011,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ChangeState<S, {
     result: Selectable<S["table"]>[K];
-    input: ColumnValues<S["table"]>[K];
+    valueType: ColumnValueType<S["table"], K>;
     rows: OneValueRows<S["rows"]>;
     value: true;
   }>, Kind>;
@@ -884,7 +1024,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   get<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ChangeState<S, {
     result: ExpressionValue<E>;
-    input: ExpressionInput<E>;
+    valueType: ExpressionValueType<E>;
     rows: OneValueRows<S["rows"]>;
     value: true;
   }>, Kind>;
@@ -895,7 +1035,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   pluck<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ChangeState<S, {
     result: Selectable<S["table"]>[K];
-    input: ColumnValues<S["table"]>[K];
+    valueType: ColumnValueType<S["table"], K>;
     rows: ValueRows<S["rows"]>;
     value: true;
   }>, Kind>;
@@ -906,7 +1046,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    */
   pluck<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ChangeState<S, {
     result: ExpressionValue<E>;
-    input: ExpressionInput<E>;
+    valueType: ExpressionValueType<E>;
     rows: ValueRows<S["rows"]>;
     value: true;
   }>, Kind>;
@@ -915,65 +1055,79 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    *
    * It keeps the filters and ignores the order; with `limit` or `offset`, it counts the rows of that page.
    */
-  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<AggregateState<S, number, number>, Kind>;
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<CountState<S>, Kind>;
   /** Replaces the selected fields with the number of the values of the column other than `NULL` among the rows of the query and returns it instead of the rows. */
-  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, number, number>, Kind>;
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<CountState<S>, Kind>;
   /** Replaces the selected fields with the number of the values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows. */
-  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, number, number>, Kind>;
+  count<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<CountState<S>, Kind>;
   /** Replaces the selected fields with the number of the distinct values of the column other than `NULL` among the rows of the query and returns it instead of the rows. */
-  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, number, number>, Kind>;
+  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<CountState<S>, Kind>;
   /** Replaces the selected fields with the number of the distinct values other than `NULL` of the expression returned by `callback` among the rows of the query and returns it instead of the rows. */
-  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, number, number>, Kind>;
+  countDistinct<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<CountState<S>, Kind>;
   /** Replaces the selected fields with the smallest value of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with the smallest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  min<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the largest value of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with the largest value of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  max<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the sum of the values of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with the sum of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`. */
-  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  sum<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the average of the values of the column among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values. */
-  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with the average of the values of the expression returned by `callback` among the rows of the query and returns it instead of the rows, or `null` without values other than `NULL`; for `bigint` values, average an expression of a type that can represent fractional values. */
-  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  avg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with whether every value of the Boolean column other than `NULL` among the rows of the query is true and returns it instead of the rows, or `null` without such values. */
-  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with whether every value other than `NULL` of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without such values. */
-  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  every<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with whether any value of the Boolean column among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`. */
-  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with whether any value of the Boolean expression returned by `callback` among the rows of the query is true and returns it instead of the rows, or `null` without values other than `NULL`. */
-  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  some<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
   /** Replaces the selected fields with the values of the text column other than `NULL` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values. */
-  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K, delimiter: string): SelectQuery<AggregateState<S, Selectable<S["table"]>[K] | null, ColumnValues<S["table"]>[K]>, Kind>;
+  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, K extends keyof S["table"]["columns"] & string>(this: SelectQuery<S, Kind>, key: K, delimiter: string): SelectQuery<ColumnAggregateState<S, K>, Kind>;
   /** Replaces the selected fields with the values other than `NULL` of the text expression returned by `callback` among the rows of the query, joined with `delimiter` in the order of the query, and returns them instead of the rows, or `null` without such values. */
-  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E, delimiter: string): SelectQuery<AggregateState<S, ExpressionValue<E> | null, ExpressionInput<E>>, Kind>;
+  stringAgg<S extends UnaggregatedQueryState, Kind extends SelectQueryKind, E extends TypedExpression>(this: SelectQuery<S, Kind>, callback: (columns: ColumnRefs<S["table"]>) => E, delimiter: string): SelectQuery<ExpressionAggregateState<S, E>, Kind>;
+  /**
+   * Replaces the selected fields with whether the query has a row and returns it instead of the rows, such as to filter by related records in `where`.
+   *
+   * It keeps the filters, the limit, and the offset, and ignores the order.
+   */
+  exists<S extends UnaggregatedQueryState, Kind extends SelectQueryKind>(this: SelectQuery<S, Kind>): SelectQuery<AggregateState<S, boolean, ExistsValueType>, Kind>;
   /**
    * Replaces a `NULL` value of a query of values, such as one made by `get`, `pluck`, or an aggregate, with `fallback`, such as `0` for a sum without rows.
    *
-   * `fallback` is a value that the type of the value accepts or an expression of its values, such as a column of the row of a parent query.
+   * `fallback` is a value that the type of the value accepts, an expression of its values, such as a column of the row of a parent query, or a query of one such value.
    * A missing row stays missing: an optional query still resolves to `undefined` without a row.
    */
-  coalesce<S extends ValueQueryState, Kind extends SelectQueryKind, F extends Operand<S["result"], S["input"]>>(this: SelectQuery<S, Kind>, fallback: F): SelectQuery<ChangeState<S, {
+  coalesce<S extends CoalesceQueryState, Kind extends SelectQueryKind, F extends Operand<S["result"], S["valueType"]["input"]>>(this: SelectQuery<S, Kind>, fallback: F): SelectQuery<ChangeState<S, {
     result: CoalescedValue<S["result"], F>;
   }>, Kind>;
+  /**
+   * Returns an expression of the value of a query of one value, such as of `get` or of an aggregate, with the operators of its type, such as `form.fields.count().expr().gt(3)`.
+   *
+   * Without a row, the expression is `NULL`, and the query does not reject.
+   */
+  expr<Q extends QueryOf<ExpressionQueryState>>(this: Q): Expression<ScalarQueryValue<Q>, Q["types"]["valueType"]["operators"], Q["types"]["valueType"]["input"]>;
   /**
    * Sorts the rows by the sort keys returned by `callback`, after the sort keys of earlier calls.
    *
-   * `callback` receives the columns and the fields selected so far, and returns an expression, sorted in ascending order, `asc`, `desc`, or `orderBy` of an expression, or an array of them.
-   * A selected field sorts by the value of the field, also when it changes from row to row, such as `random()`.
+   * `callback` receives the columns with the queries of the relations of the table, and the fields selected so far.
+   * It returns an expression or a query of one value, such as of an aggregate of related records, sorted in ascending order, `asc`, `desc`, or `orderBy` of one, or an array of them.
+   * A selected field sorts by the value of the field, also when it changes from row to row, such as `random()`; a field of nested rows cannot be sorted by.
    */
-  orderBy<Q extends QueryOf<RecordQueryState$1>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]>, selected: SelectedRefs<Q["types"]["result"]>) => OrderTerms): Q;
+  orderBy<Q extends QueryOf<RecordQueryState$1>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, selected: SelectedRefs<Q["types"]["result"]>) => OrderTerms): Q;
   /**
    * Sorts the values of a query made by `get` or `pluck` by the sort keys returned by `callback`, after the sort keys of earlier calls.
    *
-   * `callback` receives the columns and the expression of the value, and returns an expression, sorted in ascending order, `asc`, `desc`, or `orderBy` of an expression, or an array of them.
+   * `callback` receives the columns with the queries of the relations of the table, and the expression of the value.
+   * It returns an expression or a query of one value, sorted in ascending order, `asc`, `desc`, or `orderBy` of one, or an array of them.
    */
-  orderBy<Q extends QueryOf<ValueQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]>, value: AnyExpression<Q["types"]["result"]>) => OrderTerms): Q;
+  orderBy<Q extends QueryOf<ValueQueryState>>(this: Q, callback: (columns: ColumnRefs<Q["types"]["table"]> & RelationRefs<Q["types"]["schema"]>, value: AnyExpression<Q["types"]["result"]>) => OrderTerms): Q;
   /** Sorts the rows by the listed columns in ascending order, or in the directions of objects of columns, after the sort keys of earlier calls. */
   orderBy<Q extends AnySelectQuery>(this: Q, ...keys: OrderKey<Q["types"]["table"]>[]): Q;
   /** Returns at most `count` rows of a query of many rows, replacing an earlier limit. */
@@ -1045,6 +1199,18 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
    */
   toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /**
+   * Returns the node of the query as an operand of an expression, which lowering replaces with a scalar subquery of its value, or with `EXISTS` of its rows for a query of `exists`.
+   *
+   * It rejects a query of records or of rows `many`, which `ScalarQuery` rejects in types.
+   */
+  [operandNode](): ExpressionNode;
+  /**
+   * Returns the node of the query as the values of `in`, which lowering replaces with its statement.
+   *
+   * 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. */
   private derive;
   /**
@@ -1053,7 +1219,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
    * It adds the changes of `take` to `changes`, which must leave the limit as it is.
    */
   private deriveTaken;
-  /** Creates the query of the value of `projection`, an aggregate over the rows of this query, which always returns one row. */
+  /** Creates the query of the value of `projection`, of an aggregate or of `exists` over the rows of this query, which always returns one row. */
   private deriveAggregate;
   /** Creates the query of the aggregate of `method` over `arg`, a column key or a callback that receives the columns and returns an expression; `delimiter` is the delimiter of `stringAgg`. */
   private aggregateBy;
@@ -1065,7 +1231,7 @@ declare class SelectQuery<out S extends SelectQueryState, out Kind extends Selec
   private changeOneRow;
   /** Rejects a change of the selection by `method` of a query made by `get`, `pluck`, or an aggregate method. */
   private rejectValue;
-  /** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method. */
+  /** Rejects `method`, which replaces the value or the selection, on a query made by an aggregate method or `exists`. */
   private rejectAggregate;
 }
 /** Select query bound to a `Db`, executed by awaiting it; every method returns a query bound to the same `Db`. */
@@ -1078,36 +1244,34 @@ type ResultOf<Q extends AnyQuery> = Q["types"]["result"];
 type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
 /** Starts a query over a new occurrence of the table. */
 declare function from<T extends AnyTable>(table: T): SelectQuery<InitialQueryState<T>>;
-/** Expressions and nested queries selected under the keys of the result fields; a record has no symbol keys. */
-interface Selection {
-  readonly [key: string]: TypedExpression | NestedQuery;
-  readonly [key: symbol]: never;
+/** Runtime mark of the operators of `equalityOperators`, which tell that a type has SQL `=`. */
+declare const equalityBrand: unique symbol;
+/** Generic operator of `equalityOperators`, which gives the type it is added to SQL `=`. */
+interface EqualityOperator<S extends OperatorSignature> extends GenericOperator<S> {
+  readonly [equalityBrand]: true;
 }
-/** Query whose rows a selection nests as the value of a field: a query of any state and kind, such as a query of a relation. */
-type NestedQuery = QueryOf<SelectQueryState>;
-/** Record of the values of the expressions and of the nested rows of a selection. */
-type SelectionResult<S extends Selection> = { [K in keyof S]: FieldValue<S[K]>; };
-/** Value of a selected field: of an expression, or of the nested rows of a query as the result of executing it, for each member of a union of them. */
-type FieldValue<V> = V extends NestedQuery ? QueryResult<V["types"]> : ExpressionValue<V>;
-/** Relations whose records the nested queries of a selection select. */
-type SelectionUses<S extends Selection> = S[keyof S] extends (infer V) ? V extends NestedQuery ? V["types"]["uses"] : never : never;
-/** Value of a selected expression. */
-type ExpressionValue<E> = E extends AnyExpression<infer T> ? T : never;
-/** Values that the type of an expression encodes, such as in place of its value. */
-type ExpressionInput<E> = E extends AnyExpression<unknown, infer I> ? I : never;
-declare const helperFields: unique symbol;
-/** Marker of the input fields of a helper, carrying the keys selected by its callback. */
-interface HelperFields<Keys extends PropertyKey = PropertyKey> {
-  readonly [helperFields]: Keys;
+/** Key of the method of a query of a table that returns its node as the values of `in`, or rejects a query of records. */
+declare const valuesQueryNode: unique symbol;
+/** Signature of `in`: membership in a list of operands of the expression type, or in the values of a query, such as of `pluck`; an empty list or query yields `FALSE`. */
+interface InSignature extends OperatorSignature {
+  readonly method: <const L extends readonly Operand<this["T"], this["I"]>[] | ValuesQuery<NonNullable<this["T"]> | null>>(list: L) => Expression<L extends readonly unknown[] ? L extends readonly [] ? boolean : BooleanResult<this["T"] | OperandValue<L[number]>> : BooleanResult<this["T"] | (L extends ValuesQuery ? ValuesQueryValue<L> : never)>>;
 }
-/** Records with `Fields` added or replaced, for each branch of either record type; `any` stays `any`. */
-type MergeSelection<Previous, Fields> = Previous extends unknown ? Fields extends unknown ? MergeFields<RecordFields<Previous>, RecordFields<Fields>> & (IsAny<Previous> extends true ? Previous : unknown) : never : never;
-/** Fields with numeric keys represented as the string keys used in result records. */
-type RecordFields<Fields> = Fields extends unknown ? [Extract<keyof Fields, number>] extends [never] ? Fields : { [K in keyof Fields as K extends number ? `${K}` : K]: Fields[K]; } : never;
-/** Merge of normalized fields, retaining the previous value when an optional replacement is absent. */
-type MergeFields<Previous, Fields> = Simplify<{ [K in keyof Previous as K extends keyof Fields ? ({} extends Pick<Fields, K> ? K : never) : K]: K extends typeof helperFields // A branch selecting extra keys must not be reduced to one selecting fewer fields or none.
- ? Previous[K] | keyof Fields : K extends keyof Fields // A decoder can return undefined, so it cannot be excluded as merely an absent property.
- ? Previous[K] | Fields[K] : Previous[K]; } & { [K in keyof Fields as K extends keyof Previous ? ({} extends Pick<Fields, K> ? never : K) : K]: Fields[K]; }>;
+/** Operators of `equalityOperators`. */
+type EqualityOperators = {
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
+};
+/** Tells whether operators `O` include an operator of `equalityOperators`, so that their type has SQL `=`. */
+type HasEquality<O> = true extends { [K in keyof O]: O[K] extends {
+  readonly [equalityBrand]: true;
+} ? true : false; }[keyof O] ? true : false;
+/**
+ * Operators of SQL equality: `eq`, `ne`, and `in`; `orderingOperators` include them.
+ *
+ * A type has SQL `=` only with these operators, so that an array of it has them too; another operator named `eq` does not give it `=`.
+ */
+declare const equalityOperators: EqualityOperators;
 /** 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;
@@ -1115,10 +1279,10 @@ interface RecordQueryState<R = unknown, U extends UsedRelation = UsedRelation> e
   readonly value: false;
   readonly uses: U;
 }
-/** State of the query of `$select` of `Sel`: the record of the values of its expressions and the results of its queries. */
+/** State of the query of `$select` of `Sel`: the record of the values of its expressions and of its literals and the results of its queries. */
 type SelectionState<Sel extends Selection> = RecordQueryState<MergeSelection<EmptyRecord, SelectionResult<Sel>>, SelectionUses<Sel>>;
 /**
- * Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and the results of independent queries, selected in one statement.
+ * Immutable query of `$select` of state `S`, unbound or bound to a `Db`: one record whose fields are the values of expressions and of literals and the results of independent queries, selected in one statement.
  *
  * An unbound query is not thenable, so it can be returned from async functions; it is compiled with `toSQL` or executed by a `Db`.
  * A bound query executes on its `Db` when awaited.
@@ -1137,6 +1301,8 @@ declare class RecordQuery<out S extends RecordQueryState, out Kind extends Selec
    * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
    */
   toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+  [operandNode](): never;
 }
 /** Query of `$select` of any state and kind. */
 type AnyRecordQuery = RecordQuery<any, SelectQueryKind>;
@@ -1170,7 +1336,7 @@ interface SchemaMembers<T extends Tables, R extends SchemaRelations> extends Sch
    */
   $relations<S extends AnySchema, D extends RelationDeclarations<S["$tables"]>>(this: S, relations: D & CheckDeclarations<S["$tables"], D>): Schema<S["$tables"], MergeRelations<S[typeof schemaRelations] & DeclaredRelations<S["$tables"], D>>>;
   /**
-   * Starts an unbound query of one record whose fields are the values of the expressions and the results of the queries of `selection`, selected in one statement.
+   * Starts an unbound query of one record whose fields are the values of the expressions and of the literals and the results of the queries of `selection`, selected in one statement.
    *
    * The value of the field of a query is the result it gives when executed, such as an array of records or one value.
    */
@@ -1456,6 +1622,8 @@ declare class MutationQuery<out S extends MutationQueryState, out Kind extends S
    * A query bound to a `Db` compiles as the `Db` executes it, with the PostgreSQL schema of the `Db`, and rejects options.
    */
   toSQL(...args: ToSQLArgs<Kind>): SqlStatement;
+  /** Rejects the query as an operand of an expression, which takes a query of one value of a table. */
+  [operandNode](): never;
   /** Creates a mutation of the same kind and `Db` with the node changes applied. */
   private derive;
   /** Creates the mutation that returns the value of `arg` of `method`, a column key or a callback that receives the columns and returns an expression, of each changed row. */
@@ -1580,6 +1748,8 @@ declare class SqlQuery<out S extends SqlQueryState> {
   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`. */
@@ -1685,6 +1855,19 @@ declare class TransactionCoordinator {
    * A failed cleanup after an error rejects with a `SuppressedError` that keeps the original error in its `suppressed` chain.
    */
   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.
    *
@@ -1755,6 +1938,22 @@ interface Database extends AsyncDisposable {
    * 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>;
 }
@@ -1822,7 +2021,7 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
    */
   $execute<Q extends DbQuery<T, R>>(query: Q): Promise<QueryResult<Q["types"]>>;
   /**
-   * Starts a query of one record whose fields are the values of the expressions and the results of the queries of `selection`, selected in one statement when awaited.
+   * Starts a query of one record whose fields are the values of the expressions and of the literals and the results of the queries of `selection`, selected in one statement when awaited.
    *
    * A query of `selection` is unbound or bound to this `Db`, and the value of its field is the result it gives when executed, such as an array of records or one value.
    */
@@ -1830,7 +2029,7 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
   /**
    * Starts a query of the SQL statement of the template, which resolves to the number of the rows of its command tag when awaited, such as the rows that an `UPDATE` changes; `select`, `get`, and `pluck` return the fields of its rows instead.
    *
-   * Interpolated values become query parameters, `sql` fragments and expressions stay SQL, and a table of the `Db`, such as `db.form`, becomes its name, qualified by the PostgreSQL schema of the `Db`.
+   * Interpolated values become query parameters, `sql` fragments and expressions stay SQL, a table of the `Db`, such as `db.form`, becomes its name, qualified by the PostgreSQL schema of the `Db`, and another query becomes a subquery, as in `sql`.
    */
   $query(strings: TemplateStringsArray, ...values: unknown[]): SqlQuery<InitialSqlQueryState>;
   /**
@@ -1842,7 +2041,7 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
   /**
    * Executes the script of the template as `$script` of its text does.
    *
-   * It interpolates tables of the `Db`, such as `db.form`, and `sql` fragments without values; it rejects values, since a script has no parameters.
+   * It interpolates tables of the `Db`, such as `db.form`, and queries and `sql` fragments without parameters; it rejects values, since a script has no parameters.
    */
   $script(strings: TemplateStringsArray, ...values: unknown[]): Promise<void>;
   /**
@@ -1851,6 +2050,22 @@ interface DbMethods<T extends Tables, R extends SchemaRelations> {
    * Inside an existing transaction, it starts a nested transaction.
    */
   $transaction<Result>(callback: () => Promise<Result>, options?: TransactionOptions): Promise<Result>;
+  /**
+   * Runs `callback` in the current transaction without a nested transaction, or in a new transaction of the database 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<Result>(callback: () => Promise<Result>): Promise<Result>;
+  /** 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.
+   *
+   * 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>;
 }
 /**
  * `Db` of schema `S`, such as the type of a parameter of code shared by several schemas.
@@ -1927,6 +2142,19 @@ interface ValuesNode {
   readonly kind: "values";
   readonly values: Readonly<Record<string, unknown>>;
 }
+/**
+ * Query of a table in an expression, such as of `exists` in a condition, which lowering replaces with the SQL of its value before compilation.
+ *
+ * A query interpolated into SQL text may be of records or of rows `many`, which lowering replaces with its statement.
+ */
+interface NestedQueryNode {
+  readonly kind: "nestedQuery";
+  readonly query: QueryNode;
+  /** `Db` that the query is bound to, which must be the `Db` that runs the statement. */
+  readonly db: AnyDb | undefined;
+  /** Selected field of an aggregate or of `exists` whose value the node is, in a reference of the callback of `orderBy`, by which lowering sorts by the projection of the field. */
+  readonly field?: NestedSelectionNode;
+}
 interface ComparisonNode {
   readonly kind: "comparison";
   readonly operator: "=" | "<>" | "<" | "<=" | ">" | ">=" | "LIKE" | "ILIKE";
@@ -1939,6 +2167,13 @@ interface InNode {
   /** Never empty: an empty list is represented as a `FALSE` boolean node. */
   readonly list: readonly ExpressionNode[];
 }
+/** `IN` of the values of a query, such as of `pluck`, whatever its rows. */
+interface InQueryNode {
+  readonly kind: "inQuery";
+  readonly operand: ExpressionNode;
+  /** Query of the values: a query in an expression, which lowering replaces with its statement of one projection. */
+  readonly query: NestedQueryNode | SelectNode;
+}
 interface IsNullNode {
   readonly kind: "isNull";
   readonly operand: ExpressionNode;
@@ -1966,6 +2201,11 @@ interface ExistsNode {
   readonly kind: "exists";
   readonly query: SelectNode;
 }
+/** Subquery interpolated into SQL text: its query in parentheses, of any fields and rows, which the text reads, such as with `EXISTS` or in `FROM`. */
+interface TextSubqueryNode {
+  readonly kind: "textSubquery";
+  readonly query: SelectNode;
+}
 /** Call of an aggregate function over the rows of its query, with the order of its input rows. */
 interface AggregateNode {
   readonly kind: "aggregate";
@@ -1976,7 +2216,7 @@ interface AggregateNode {
   readonly arguments: readonly ExpressionNode[];
   readonly orderBy: readonly OrderNode[];
 }
-type ExpressionNode = ColumnRefNode | ParamNode | CastNode | BooleanNode | AndNode | OrNode | NotNode | ValuesNode | ComparisonNode | InNode | IsNullNode | RawSqlNode | TableNameNode | SubqueryNode | ExistsNode | AggregateNode;
+type ExpressionNode = ColumnRefNode | ParamNode | CastNode | BooleanNode | AndNode | OrNode | NotNode | ValuesNode | NestedQueryNode | ComparisonNode | InNode | InQueryNode | IsNullNode | RawSqlNode | TableNameNode | SubqueryNode | ExistsNode | TextSubqueryNode | AggregateNode;
 /**
  * Filters of a query, kept apart so that composing one kind never changes the others.
  *
@@ -2025,6 +2265,8 @@ interface SelectNode<From extends SourceNode | undefined = SourceNode | undefine
   readonly offset: ExpressionNode | undefined;
   /** Required relation that guarantees the row of the query, such as `field.form`; see `ResultPlan`. */
   readonly guaranteedBy: string | undefined;
+  /** Template of the records of a query with literals; see `ResultPlan`. */
+  readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
 }
 /** Assignment of `SET` of an update: the value of the column under `key`. */
 interface AssignmentNode {
@@ -2039,6 +2281,8 @@ interface AssignmentNode {
 interface MutationParts<Field> extends ResultMode {
   readonly target: TableSourceNode;
   readonly returning: readonly Field[] | undefined;
+  /** Template of the records of a mutation with literals; see `ResultPlan`. */
+  readonly recordTemplate?: readonly RecordTemplateField[] | undefined;
 }
 /** Insert statement of rows of `VALUES`. */
 interface InsertNode<Field = ProjectionNode> extends MutationParts<Field> {
@@ -2076,6 +2320,8 @@ interface TextStatementNode extends ResultMode {
 declare const valueType: unique symbol;
 declare const inputType: unique symbol;
 declare const typed: unique symbol;
+/** Key of the method of an expression and of every class of queries that returns its node as an operand of an expression, or rejects a query that cannot be one. */
+declare const operandNode: unique symbol;
 /** Expression of TypeScript type `T` accepting compared values of type `I`, whatever its operators. */
 interface AnyExpression<T = unknown, I = unknown> {
   readonly [valueType]: T;
@@ -2090,19 +2336,236 @@ type ExpressionWithOperators<T, O extends OperatorDefinitions, I> = AnyExpressio
  * It has `isNull` and the operators `O` of its type, which also decodes its values, so it can be selected.
  * The AST node behind it is internal.
  */
-type Expression<T = unknown, O extends OperatorDefinitions = EqualityOperators, I = T> = ExpressionWithOperators<T, O, I> & TypedExpression<T>;
+type Expression<T = unknown, O extends OperatorDefinitions = EqualityOperators, I = T> = ExpressionWithOperators<T, O, I> & TypedExpression<T, O>;
 /**
  * Expression of TypeScript type `T` without a type, such as a fragment of `sql<T>`, with the operators of `equalityOperators`.
  *
  * Nothing decodes its values to `T`, so it cannot be selected.
  */
 type UntypedExpression<T = unknown> = ExpressionWithOperators<T, EqualityOperators, NoInfer<T>>;
-/** Expression that has a type to decode its values, which `select`, `get`, and `pluck` require. */
-type TypedExpression<T = unknown> = AnyExpression<T> & {
-  readonly [typed]: true;
+/** Expression that has a type to decode its values, which `select`, `get`, and `pluck` require, with the operators `O` of the type. */
+type TypedExpression<T = unknown, O extends OperatorDefinitions = any> = AnyExpression<T> & {
+  readonly [typed]: O;
 };
+/** Operators of expression `E`. */
+type ExpressionOperators<E extends TypedExpression> = E[typeof typed];
 /** Operators of expressions of every type. */
 interface BaseOperators {
   isNull(): Expression<boolean>;
 }
-export { many as $, BaseType as $n, Predicate as $t, SqlQuery as A, ColumnDefinitions as An, UpdateSet as At, Relation as B, defineTable as Bn, desc as Bt, createTestHelpers as C, ComparisonSignature as Cn, FilteredStateRows as Ct, DecodedFields as D, CompileOptions as Dn, from as Dt, AnySqlQuery as E, compare as En, TableOrQuery as Et, MutationQueryState as F, Selectable as Fn, OrderTerm as Ft, RelationKind as G, ResultRows as Gn, EqValue as Gt, RelationDeclarations as H, RequiredRelationError as Hn, KeyCheck as Ht, DeclaredRelations as I, Table as In, OrderTerms as It, SchemaRelations as J, DriverResult as Jn, WhereValues as Jt, RequiredMember as K, Connection as Kn, WhereCondition as Kt, MergeRelations as L, TableKeys as Ln, Ordering as Lt, AnyMutationQuery as M, ColumnShape as Mn, OrderColumns as Mt, InitialMutationState as N, ColumnValues as Nn, OrderDirection as Nt, FieldTypes as O, AnyTable as On, ColumnValue as Ot, MutationQuery as P, KeyColumns as Pn, OrderKey as Pt, UsedRelation as Q, AnyType as Qn, ConditionOperand as Qt, NoRelations as R, TableOptions as Rn, SelectedRefs as Rt, TestTransactionOptions as S, BooleanResult as Sn, ChangeState as St, SelectQueryKind as T, OperandValue as Tn, SelectQuery as Tt, RelationKey as U, ResultDecodeError as Un, NotAKey as Ut, RelationDeclaration as V, NotFoundError as Vn, orderBy as Vt, RelationKeys as W, ResultMode as Wn, PrimaryKeyValues as Wt, TableRelations as X, TransactionFailure as Xn, CombinedCondition as Xt, TableContext as Y, SqlStatement as Yn, defineFilter as Yt, UsableRelation as Z, createStatement as Zn, Condition as Zt, OpenedTestFixture as _, EqualityOperator as _n, GenericOperator as _r, Selection as _t, UntypedExpression as a, RelationRefs as an, TypeOutput as ar, SchemaTables as at, TestHelpers as b, InSignature as bn, defineGenericOperator as br, AnySelectQuery as bt, Db as c, OneValueRows as cn, AnyColumn as cr, AnyRecordQuery as ct, DbQueryState as d, ValueRows as dn, KeyKind as dr, SelectionState as dt, and as en, TextValue as er, one as et, Database as f, EmptyRecord as fn, ToColumn as fr, ExpressionInput as ft, TransactionCoordinator as g, SelectQueryState as gn, OperatorDefinitions as gr, NestedQuery as gt, createDatabase as h, QueryStateOf as hn, NoOperators as hr, MergeSelection as ht, TypedExpression as i, QueryContext as in, TypeOptions as ir, SchemaPartRelations as it, SqlQueryState as j, ColumnOperators as jn, UpdateValues as jt, InitialSqlQueryState as k, AnyTableKeys as kn, InsertValues as kt, DbMutationState as l, QueryResult as ln, Column as lr, RecordQuery as lt, TransactionOptions as m, QueryState as mn, MergeOperators as mr, HelperFields as mt, BaseOperators as n, or as nn, TypeInput as nr, Schema as nt, AnyDb as o, FilteredRows as on, TypeTransform as or, Tables as ot, DatabaseOptions as p, InitialQueryState as pn, BoundOperators as pr, ExpressionValue as pt, SchemaContext as q, Driver as qn, WhereFilter as qt, Expression as r, ColumnRefs as rn, TypeOperators as rr, SchemaPart as rt, BindOptions as s, OneRow as sn, defineType as sr, defineSchema as st, AnyExpression as t, not as tn, Type as tr, AnySchema as tt, DbOf as u, ResultByRows as un, ColumnAttributes as ur, RecordQueryState as ut, PendingTestFixture as v, EqualityOperators as vn, GenericOperatorImplementation as vr, SelectionResult as vt, AnyQuery as w, Operand as wn, ResultOf as wt, TestHooks as x, equalityOperators as xn, BoundSelectQuery as xt, TestFixture as y, HasEquality as yn, OperatorSignature as yr, SelectionUses as yt, OneRelationKeys as z, ToColumns as zn, asc as zt };
+/** Operators of ordered types: those of `equalityOperators`, and `lt`, `lte`, `gt`, and `gte` comparing with operands of the expression type. */
+declare const orderingOperators: {
+  lt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  lte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
+  eq: EqualityOperator<ComparisonSignature>;
+  ne: EqualityOperator<ComparisonSignature>;
+  in: EqualityOperator<InSignature>;
+};
+/** Operators of the built-in types of numbers: those of `orderingOperators`. */
+type NumberTypeOperators = MergeOperators<NoOperators, typeof orderingOperators>;
+/** Signature of pattern matching: patterns stay strings even when the text values are transformed. */
+interface PatternSignature extends OperatorSignature {
+  readonly method: <V extends Operand<string>>(pattern: V) => Expression<BooleanResult<this["T"] | OperandValue<V>>>;
+}
+/** Signature of `lower`, `upper`, and `trim`: a value of `text`, whatever the representation of the text values, and `NULL` when the text can be. */
+interface TextConversionSignature extends OperatorSignature {
+  readonly method: () => Expression<string | (null extends this["T"] ? null : never), TextTypeOperators>;
+}
+/** Signature of `length`: the number of characters of the text, and `NULL` when the text can be. */
+interface TextLengthSignature extends OperatorSignature {
+  readonly method: () => Expression<number | (null extends this["T"] ? null : never), NumberTypeOperators>;
+}
+/** Operators of `textOperators`. */
+type TextOperators = {
+  like: GenericOperator<PatternSignature, AnyExpression<string | null>>;
+  ilike: GenericOperator<PatternSignature, AnyExpression<string | null>>;
+  lower: GenericOperator<TextConversionSignature, AnyExpression<string | null>>;
+  upper: GenericOperator<TextConversionSignature, AnyExpression<string | null>>;
+  trim: GenericOperator<TextConversionSignature, AnyExpression<string | null>>;
+  length: GenericOperator<TextLengthSignature, AnyExpression<string | null>>;
+};
+/** Operators of the built-in text types: those of `orderingOperators` and `textOperators`. */
+type TextTypeOperators = MergeOperators<MergeOperators<NoOperators, typeof orderingOperators>, TextOperators>;
+/**
+ * Operators of text types: pattern matching with `LIKE` and `ILIKE`, `lower` and `upper`, which convert the case of the text, `trim`, which removes spaces from both of its ends, and `length`, which counts its characters.
+ *
+ * A string pattern is sent as it is; `param(type, pattern)` encodes it with a type.
+ */
+declare const textOperators: TextOperators;
+/** Condition that always holds, such as for a branch of `and` built in code: `and(check, isAdmin ? TRUE : other)`. */
+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>;
+/** First operand of `coalesce`, `greatest`, and `least`: an expression with a type, or a query of one value, such as of an aggregate, whose type decodes the result and gives it its operators. */
+type TypedOperand = TypedExpression | TypedScalarQuery;
+/** Values that the type of the first operand `F` encodes. */
+type TypedOperandInput<F> = F extends TypedScalarQuery ? F["types"]["valueType"]["input"] : ExpressionInput<F>;
+/** Operators of the type of the first operand `F`. */
+type TypedOperandOperators<F> = F extends TypedScalarQuery ? F["types"]["valueType"]["operators"] : F extends TypedExpression ? ExpressionOperators<F> : never;
+/** Operand of `coalesce`, `greatest`, and `least` after the first operand `F`: a value that its type encodes, or an expression or a query of one value of its values. */
+type FollowingOperand<F> = Operand<OperandValue<F>, TypedOperandInput<F>>;
+/** `null` when every operand can be `NULL`: the first operand `F` and the following operands `R`. */
+type NullOfEveryOperand<F, R extends readonly unknown[]> = null extends OperandValue<F> ? number extends R["length"] ? null : { [K in keyof R]: null extends OperandValue<R[K]> ? never : true; }[number] extends never ? null : never : never;
+/** Result of a function of the first operand `F` and the following operands `R` that is `NULL` only when every operand is, whose operands all have the values of `F`. */
+type NullSkippingResult<F, R extends readonly unknown[]> = Expression<Exclude<OperandValue<F>, null> | NullOfEveryOperand<F, R>, TypedOperandOperators<F>, TypedOperandInput<F>>;
+/**
+ * Returns the first of its operands other than `NULL`, such as `coalesce(field.hint, "")`, as an expression usable wherever a column is.
+ *
+ * `first` is an expression with a type or a query of one value; its type decodes the result and gives it its operators, and encodes plain values among `rest`.
+ * A query without its row is `NULL` here, unlike with the method `coalesce` of a query, which keeps a missing row missing.
+ */
+declare function coalesce<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
+/**
+ * Returns the largest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
+ *
+ * `first` is an expression with a type or a query of one value; its type decodes the result and gives it its operators, and encodes plain values among `rest`.
+ */
+declare function greatest<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
+/**
+ * Returns the smallest of its operands, skipping `NULL`, which is the result only when every operand is `NULL`.
+ *
+ * `first` is an expression with a type or a query of one value; its type decodes the result and gives it its operators, and encodes plain values among `rest`.
+ */
+declare function least<F extends TypedOperand, const R extends readonly FollowingOperand<F>[]>(first: F, ...rest: R): NullSkippingResult<F, R>;
+/** Condition of a branch of `caseWhen`: a predicate, or a query of one Boolean value, such as of `exists`. */
+type CaseCondition = Predicate | ScalarQuery<boolean | null>;
+/** Value of a branch of `caseWhen` of a type of values `T` that encodes values `I`: an operand of the type, or a plain `null`. */
+type CaseValue<T, I> = Operand<T, I> | null;
+/** Branch of `caseWhen`: a condition and the value of the result when it holds. */
+type CaseBranch<T, I> = readonly [condition: CaseCondition, value: CaseValue<T, I>];
+/** Value of `caseWhen` of a type of values `T` whose branches and fallback have the values `V`, of which one gives the result. */
+type CaseResult<T, V> = Exclude<T, null> | Extract<OperandValue<V>, null>;
+/**
+ * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `NULL` when none holds.
+ *
+ * `type` decodes the result and gives it its operators, and a plain value of a branch is cast to it, so that PostgreSQL does not take plain values for text.
+ */
+declare function caseWhen<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>, branches: NoInfer<readonly CaseBranch<Output, Input>[]>): Expression<Exclude<Output, null> | null, O, Input>;
+/**
+ * Returns the value of the first branch whose condition holds, as a SQL `CASE` expression, or `otherwise` when none holds.
+ *
+ * `type` decodes the result and gives it its operators, and a plain value of a branch or of `otherwise` is cast to it, so that PostgreSQL does not take plain values for text.
+ */
+declare function caseWhen<Output, Input, O extends OperatorDefinitions, const B extends readonly CaseBranch<Output, Input>[], const E extends CaseValue<Output, Input>>(type: Type<Output, Input, O, any>, branches: B, otherwise: E): Expression<CaseResult<Output, B[number][1] | E>, O, Input>;
+/**
+ * State of the query that the callback of a helper of table `T` with schema context `C` receives: the fields of the query the helper is applied to, and all its rows.
+ *
+ * It is guaranteed, so that the state that the callback returns tells whether the callback ends the guarantee of the query the helper is applied to.
+ */
+interface HelperState<T extends AnyTable, C extends SchemaContext> extends QueryStateOf<T, C> {
+  readonly result: HelperFields<never>;
+  readonly valueType: never;
+  readonly rows: "many";
+  readonly value: false;
+  readonly uses: never;
+  readonly guaranteed: true;
+  readonly aggregate: false;
+}
+/**
+ * Effect of a helper: the fields it selects, its rows mode on a query of many rows, `one` after `take` or `required` and `nullable` or `optional` after the method of the same name, the relations it selects records of, and whether it keeps the guarantee of the row of a query of a required relation.
+ *
+ * `reads` are the relations of the schema of the helper among them, which its callback may read from the references of the query it is applied to, and `key` is the key of its table there.
+ */
+interface HelperEffect {
+  readonly fields: object;
+  readonly rows: ResultRows;
+  readonly uses: UsedRelation;
+  readonly reads: UsedRelation;
+  readonly key: string;
+  readonly guaranteed: boolean;
+}
+/** Effect of a helper whose callback returns a query of state `S`, for each state of a union. */
+type ReadEffect<S extends SelectQueryState> = S extends SelectQueryState ? {
+  readonly fields: { [K in keyof S["result"] as K extends keyof HelperFields ? never : K]: S["result"][K]; };
+  readonly rows: S["rows"];
+  readonly uses: S["uses"];
+  readonly reads: Extract<UsableRelation<S["schema"]["relations"]>, S["uses"]>;
+  readonly key: S["schema"]["key"];
+  readonly guaranteed: S["guaranteed"];
+} : never;
+/** Error of a helper that a query does not accept, or whose callback returns a query it does not accept. */
+interface HelperError<Message extends string> {
+  readonly error: Message;
+}
+/** `unknown` when every result state retains the input marker and returns records, or the error. */
+type CheckResult<S extends SelectQueryState> = [S] extends [{
+  readonly result: HelperFields;
+  readonly value: false;
+}] ? unknown : HelperError<"A helper can filter, select fields, and take one row, but cannot clear the selection or use get, pluck, or aggregates">;
+/** State of a query over table `T` that accepts a helper of effect `E`. */
+type HelperInput<T extends AnyTable, E extends HelperEffect> = QueryStateOf<T, ReadsContext<E>> & ValueCheck<E>;
+/** Constraint of `value` of a query that accepts a helper of effect `E`. */
+type ValueCheck<E extends HelperEffect> = [E extends HelperEffect ? keyof E["fields"] : never] extends [never] ? [Extract<E["rows"], "nullable">] extends [never] ? unknown : RecordRows<"A helper cannot apply nullable to a query made by get, pluck, or an aggregate"> : RecordRows<"A helper cannot select fields on a query made by get, pluck, or an aggregate">;
+/** Constraint of a query whose rows are records, which a query of values fails with error `Message`. */
+interface RecordRows<Message extends string> {
+  readonly value: false | HelperError<Message>;
+}
+/** Schema context of a query that has the relations of its schema that a helper of effect `E` may read. */
+type ReadsContext<E extends HelperEffect> = [E["reads"]] extends [never] ? SchemaContext : SchemaContext<{ readonly [K in E["reads"]["key"]]: { readonly [N in Extract<E["reads"], {
+  readonly key: K;
+}>["name"]]: Extract<E["reads"], {
+  readonly key: K;
+  readonly name: N;
+}>["relation"]; }; }, E["key"]>;
+/** State of a query of state `S` after a helper of effect `E`. */
+type ApplyEffect<S extends SelectQueryState, E extends HelperEffect> = ChangeState<S, {
+  result: [keyof E["fields"]] extends [never] ? S["result"] : MergeSelection<S["result"], E["fields"]>;
+  rows: E["rows"] extends "many" ? EffectRows<S, E> : E["rows"] extends "one" ? OneRow<EffectRows<S, E>> : E["rows"];
+  uses: S["uses"] | E["uses"];
+  guaranteed: E["guaranteed"] extends true ? S["guaranteed"] : false;
+}>;
+/** Rows mode of a query of state `S` after a helper of effect `E` that keeps the rows, before `take`: relaxed as after a filter when the helper ends the guarantee. */
+type EffectRows<S extends SelectQueryState, E extends HelperEffect> = E["guaranteed"] extends true ? S["rows"] : FilteredStateRows<S>;
+/**
+ * Helper of `defineHelper` for queries over table `T`: it applies effect `E` to the query it receives with arguments `A` and returns a query of the same kind.
+ *
+ * Selected fields replace earlier fields under the same keys; a query made by `get`, `pluck`, or an aggregate method does not accept a helper that selects fields.
+ */
+type Helper<T extends AnyTable, E extends HelperEffect, A extends unknown[]> = <S extends HelperInput<T, E>, Kind extends SelectQueryKind>(query: SelectQuery<S, Kind>, ...args: A) => E extends HelperEffect ? SelectQuery<ApplyEffect<S, E>, Kind> : never;
+/**
+ * Defines a reusable helper of a table that filters, selects fields, and applies `take`, `optional`, `nullable`, and `required`, used with `use` or called with a query.
+ *
+ * `helper` receives the query it is applied to and any further arguments, and returns the query with its clauses.
+ * Defined with a query of a schema, such as `schema.form`, it can select the relations of the table in that schema, and applies to queries whose schema has them.
+ * The helper returns a query of the same kind as the one it is applied to, bound to the same `Db` if any.
+ */
+declare function defineHelper<T extends AnyTable, R extends SelectQuery<any, SelectQueryKind>, A extends unknown[], C extends SchemaContext = NoRelations>(table: TableOrQuery<T, C>, helper: (query: SelectQuery<HelperState<T, C>, SelectQueryKind>, ...args: A) => R & CheckResult<R["types"]>): Helper<T, ReadEffect<R["types"]>, A>;
+/** Tagged template building a SQL fragment of values `T` that accepts compared values `I`. */
+type SqlTemplate<T, O extends OperatorDefinitions, I = T> = (strings: TemplateStringsArray, ...values: unknown[]) => Expression<T, O, I>;
+/**
+ * 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.
+ * 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.
+ * 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>;
+/**
+ * Creates a template building SQL fragments of `type`.
+ *
+ * The fragments have the operators of the type and encode compared values with it; the type adds no SQL cast.
+ */
+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`.
+ *
+ * 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 name is not qualified by the PostgreSQL schema of the statement.
+ */
+declare function identifier(...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.
+ *
+ * With a type, the parameter is cast to it, such as `$1::integer`, so that PostgreSQL applies the operators of the type even where nothing else in the statement determines it.
+ * The cast omits type parameters, such as `$1::numeric` for `numeric(10,2)`, so that their precision, scale, or length do not constrain the value.
+ *
+ * With an expression, such as `param(self, other)` in an operator definition, the type of the expression encodes the value, and the parameter is not cast: PostgreSQL types it by the expression it is used with.
+ * `value` may then also be an expression, such as an operand of a generic operator, which is returned as it is, with its own type and nullability.
+ * A query of one value becomes an expression with the runtime type of the first argument and the nullability of the query, typed as an `AnyExpression` of its value.
+ */
+declare function param<Output, Input, O extends OperatorDefinitions>(type: Type<Output, Input, O, any>, value: Input): Expression<Output, O, Input>;
+declare function param<E extends AnyExpression, V extends (E extends AnyExpression<infer T, infer I> ? Operand<T, I> : never)>(type: E, value: V): V extends AnyExpression ? V : V extends ScalarQuery ? AnyExpression<ScalarQueryValue<V>> : E;
+export { SelectQueryKind as $, QueryStateOf as $n, OperatorSignature as $r, from as $t, Expression as A, WhereValues as An, TransactionFailure as Ar, Schema as At, Database as B, ColumnRefs as Bn, TypeTransform as Br, EqualityOperator as Bt, TextOperators as C, KeyCheck as Cn, ResultDecodeError as Cr, TableContext as Ct, orderingOperators as D, WhereCallback as Dn, Driver as Dr, many as Dt, NumberTypeOperators as E, EqValue as En, Connection as Er, UsedRelation as Et, BindOptions as F, Predicate as Fn, Type as Fr, defineSchema as Ft, OpenedTestFixture as G, OneValueRows as Gn, KeyKind as Gr, AnySelectQuery as Gt, TransactionOptions as H, RelationRefs as Hn, AnyColumn as Hr, HasEquality as Ht, Db as I, and as In, TypeInput as Ir, AnyRecordQuery as It, TestHelpers as J, ValueRows as Jn, MergeOperators as Jr, ResultOf as Jt, PendingTestFixture as K, QueryResult as Kn, ToColumn as Kr, BoundSelectQuery as Kt, DbMutationState as L, not as Ln, TypeOperators as Lr, RecordQuery as Lt, TypedExpression as M, CombinedCondition as Mn, AnyType as Mr, SchemaPartRelations as Mt, UntypedExpression as N, Condition as Nn, BaseType as Nr, SchemaTables as Nt, AnyExpression as O, WhereCondition as On, DriverResult as Or, one as Ot, AnyDb as P, ConditionOperand as Pn, TextValue as Pr, Tables as Pt, AnyQuery as Q, QueryState as Qn, GenericOperatorImplementation as Qr, ValuesQuery as Qt, DbOf as R, or as Rn, TypeOptions as Rr, RecordQueryState as Rt, TextLengthSignature as S, orderBy as Sn, RequiredRelationError as Sr, SchemaRelations as St, textOperators as T, PrimaryKeyValues as Tn, ResultRows as Tr, UsableRelation as Tt, createDatabase as U, FilteredRows as Un, Column as Ur, InSignature as Ut, DatabaseOptions as V, QueryContext as Vn, defineType as Vr, EqualityOperators as Vt, TransactionCoordinator as W, OneRow as Wn, ColumnAttributes as Wr, equalityOperators as Wt, TestTransactionOptions as X, EmptyRecord as Xn, OperatorDefinitions as Xr, SelectQuery as Xt, TestHooks as Y, CountValueType as Yn, NoOperators as Yr, ScalarQuery as Yt, createTestHelpers as Z, InitialQueryState as Zn, GenericOperator as Zr, TypedScalarQuery as Zt, least as _, OrderTerms as _n, TableKeys as _r, RelationKey as _t, Helper as a, ExpressionValue as an, OperandValue as ar, SqlQueryState as at, PatternSignature as b, asc as bn, defineTable as br, RequiredMember as bt, CaseBranch as c, Selection as cn, AnyTable as cr, MutationQuery as ct, FollowingOperand as d, Literal as dn, ColumnOperators as dr, MergeRelations as dt, defineGenericOperator as ei, ColumnValue as en, QueryValueType as er, AnySqlQuery as et, NullSkippingResult as f, literal as fn, ColumnShape as fr, NoRelations as ft, greatest as g, OrderTerm as gn, Table as gr, RelationDeclarations as gt, coalesce as h, OrderKey as hn, Selectable as hr, RelationDeclaration as ht, sql as i, ExpressionInput as in, Operand as ir, SqlQuery as it, ExpressionOperators as j, defineFilter as jn, createStatement as jr, SchemaPart as jt, BaseOperators as k, WhereFilter as kn, SqlStatement as kr, AnySchema as kt, CaseCondition as l, SelectionResult as ln, AnyTableKeys as lr, MutationQueryState as lt, caseWhen as m, OrderDirection as mn, KeyColumns as mr, Relation as mt, identifier as n, UpdateSet as nn, BooleanResult as nr, FieldTypes as nt, HelperEffect as o, MergeSelection as on, compare as or, AnyMutationQuery as ot, TypedOperand as p, OrderColumns as pn, ColumnValues as pr, OneRelationKeys as pt, TestFixture as q, ResultByRows as qn, BoundOperators as qr, FilteredStateRows as qt, param as r, UpdateValues as rn, ComparisonSignature as rr, InitialSqlQueryState as rt, defineHelper as s, NestedQuery as sn, CompileOptions as sr, InitialMutationState as st, SqlTemplate as t, InsertValues as tn, SelectQueryState as tr, DecodedFields as tt, CaseValue as u, SelectionUses as un, ColumnDefinitions as ur, DeclaredRelations as ut, FALSE as v, Ordering as vn, TableOptions as vr, RelationKeys as vt, TextTypeOperators as w, NotAKey as wn, ResultMode as wr, TableRelations as wt, TextConversionSignature as x, desc as xn, NotFoundError as xr, SchemaContext as xt, TRUE as y, SelectedRefs as yn, ToColumns as yr, RelationKind as yt, DbQueryState as z, ExistsValueType as zn, TypeOutput as zr, SelectionState as zt };