kern-orm 0.12.1 → 0.13.0

package/dist/{index-Cv9QJ_v7.d.mts → index-CFkH9TlC.d.mts}

@@ -161,7 +161,8 @@ interface BaseType<Output, Input, Operators extends OperatorDefinitions, Paramet
   /**
    * Narrows the values of this type to `T` in TypeScript, such as to a union of strings that a `CHECK` constraint allows, or to the shape of JSON values.
    *
-   * The values are not validated at runtime. `T` must be among the values that this type both returns and accepts, and `nullable` keeps `null` apart from it.
+   * The values are not validated at runtime.
+   * `T` must be among the values that this type both returns and accepts, and `nullable` keeps `null` apart from it.
    */
   of<T extends AcceptedValues<Exclude<Output, null>, Exclude<Input, null>>>(): Type<T | AcceptedNull<Input>, T | AcceptedNull<Input>, Operators, Parameters>;
   /** Creates a column of this type with a physical name different from the column key. */
@@ -788,19 +789,6 @@ type ToFieldRef<D, V> = D extends QueryValueType ? D extends {
  * It reads `S` only in its branch, as `QueryWhereFilter` does.
  */
 type QueryHavingFilter<S extends SelectQueryState> = [S] extends [unknown] ? WhereCondition<S["table"]> | ((columns: ColumnRefs<S["table"]> & RelationRefs<S["schema"]>, selected: HavingFields<S>) => WhereCondition<S["table"]>) : never;
-/**
- * What a query with a row lock does with a row that another transaction has locked, instead of waiting for it:
- *
- * - `skipLocked` leaves the row out of its result, such as to take the next free job of a queue.
- * - `noWait` rejects with a PostgreSQL error of SQLSTATE `55P03`.
- */
-type RowLockOptions = {
-  readonly noWait?: boolean;
-  readonly skipLocked?: false;
-} | {
-  readonly noWait?: false;
-  readonly skipLocked?: boolean;
-};
 /** Rows mode of a query of state `S` after a filter: `FilteredRows` of a query whose row is guaranteed, and the rows of other queries. */
 type FilteredStateRows<S extends SelectQueryState> = [S["guaranteed"]] extends [false] ? S["rows"] : [S["value"]] extends [false] ? S["result"] extends HelperFields ? S["rows"] : FilteredRows<S["rows"], false> : FilteredRows<S["rows"], S["value"]>;
 /** State `S` after a filter, which ends the guarantee of its row. */
@@ -929,6 +917,131 @@ type OneRowQueryState = SelectQueryState & {
 type OneRecordQueryState = OneRowQueryState & {
   readonly value: false | "mapped";
 };
+/**
+ * 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 fieldTypes: EmptyRecord;
+  readonly rows: "many";
+  readonly value: false;
+  readonly uses: never;
+  readonly guaranteed: true;
+  readonly aggregate: false;
+}
+/**
+ * Effect of a helper: the fields it selects and the types of their values, or whether `map` converts its rows and what it gives, 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 {
+  /** Whether the helper guarantees that the query is grouped. */
+  readonly grouped: boolean;
+  readonly fields: object;
+  /** Types of the values of the fields it selects, the `fieldTypes` part of the state that its callback returns, which `having` and the narrowing of grouped selections read. */
+  readonly fieldTypes: unknown;
+  /** Whether `map` converts the rows, whose fields the result no longer tells, so that `fields` are empty. */
+  readonly mapped: boolean;
+  /** What `map` gives for each row of a query the helper is applied to; `never` when `mapped` is `false`. */
+  readonly output: unknown;
+  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 grouped: S["aggregate"] extends Grouped ? true : false;
+  readonly fields: S["value"] extends "mapped" ? EmptyRecord : { [K in keyof S["result"] as K extends keyof HelperFields ? never : K]: S["result"][K]; };
+  readonly fieldTypes: S["value"] extends "mapped" ? EmptyRecord : S["fieldTypes"];
+  readonly mapped: S["value"] extends "mapped" ? true : false;
+  readonly output: S["value"] extends "mapped" ? WithoutHelperFields<S["result"]> : never;
+  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 converts such records with `map`, or the error. */
+type CheckResult<S extends SelectQueryState> = [S] extends [{
+  readonly result: HelperFields;
+  readonly value: false;
+} | {
+  readonly value: "mapped";
+  readonly valueType: never;
+}] ? unknown : HelperError<"A helper can filter, select fields, map them, 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> & (true extends E["grouped"] ? {
+  readonly aggregate: false;
+} : unknown);
+/** 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] ? [E["mapped"]] extends [false] ? unknown : RecordRows<"A helper cannot apply map to a query made by get, pluck, an aggregate, or map"> : RecordRows<"A helper cannot apply nullable to a query made by get, pluck, an aggregate, or map"> : RecordRows<"A helper cannot select fields on a query made by get, pluck, an aggregate, or map">;
+/** 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> = ApplySelectionEffect<E["grouped"] extends true ? GroupedState<S> : S, E>;
+/** Applies the selected fields and row effects after the grouping guaranteed by the helper. */
+type ApplySelectionEffect<S extends SelectQueryState, E extends HelperEffect> = ChangeState<S, {
+  result: E["mapped"] extends true ? E["output"] : [keyof E["fields"]] extends [never] ? S["result"] : MergeSelection<S["result"], S["aggregate"] extends Grouped ? GroupedRecord<E["fields"], SelectedFieldTypesOf<E["fieldTypes"]>> : E["fields"]>;
+  fieldTypes: SelectedFieldTypes<S["fieldTypes"], SelectedFieldTypesOf<E["fieldTypes"]>>;
+  value: E["mapped"] extends true ? "mapped" : S["value"];
+  aggregate: E["mapped"] extends true ? true : S["aggregate"];
+  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`, an aggregate method, or `map` does not accept a helper that selects fields or maps them.
+ * `use` of a mutation also applies a helper that only selects fields and maps them.
+ */
+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;
+/** Helper of any table, effect, and arguments. */
+type AnyHelper = Helper<AnyTable, any, any>;
+/** Type of a record of the fields that a helper of effect `E` selects, or of what its `map` gives, for each effect of a union. */
+type HelperResult<E extends HelperEffect> = E extends HelperEffect ? E["mapped"] extends true ? E["output"] : E["fields"] : never;
+/**
+ * Defines a reusable helper of a table that filters, selects fields, converts them with `map`, 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.
+ * A helper that only selects fields and maps them also applies to an insert, an update, and a delete with their `use`, where it selects what they return; other methods fail there.
+ */
+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>;
+/**
+ * What a query with a row lock does with a row that another transaction has locked, instead of waiting for it:
+ *
+ * - `skipLocked` leaves the row out of its result, such as to take the next free job of a queue.
+ * - `noWait` rejects with a PostgreSQL error of SQLSTATE `55P03`.
+ */
+type RowLockOptions = {
+  readonly noWait?: boolean;
+  readonly skipLocked?: false;
+} | {
+  readonly noWait?: false;
+  readonly skipLocked?: boolean;
+};
 /**
  * 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, an expression of its values, or a query of one such value.
  *
@@ -1468,8 +1581,12 @@ interface SingletonInsertMany {
 type BoundSelectQuery<S extends SelectQueryState> = SelectQuery<S, "bound">;
 /** Select query of any state and kind. */
 type AnySelectQuery = SelectQuery<any, SelectQueryKind>;
-/** Type of a record of a query result, also of a query of SQL text, or of its value for a query made by `get`, `pluck`, or an aggregate method. */
-type ResultOf<Q extends AnyQuery | AnySqlQuery> = Q["types"]["result"];
+/**
+ * Type of a record of a query result, also of a query of SQL text, or of its value for a query made by `get`, `pluck`, or an aggregate method.
+ *
+ * Of a helper of `defineHelper`, it is the type of a record of the fields that the helper selects, or of what its `map` gives.
+ */
+type ResultOf<Q extends AnyQuery | AnySqlQuery | AnyHelper> = Q extends AnyQuery | AnySqlQuery ? Q["types"]["result"] : Q extends Helper<AnyTable, infer E, never> ? HelperResult<E> : never;
 /** Table of a definition such as `defineExpression`: the table itself or a query over it with schema context `C`, such as `schema.form`. */
 type TableOrQuery<T extends AnyTable, C extends SchemaContext = SchemaContext> = T | QueryOf<QueryStateOf<T, C>>;
 /** Starts a query over a new occurrence of the table. */
@@ -1733,114 +1850,6 @@ declare function caseWhen<Output, Input, O extends OperatorDefinitions>(type: Ty
  * `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 fieldTypes: EmptyRecord;
-  readonly rows: "many";
-  readonly value: false;
-  readonly uses: never;
-  readonly guaranteed: true;
-  readonly aggregate: false;
-}
-/**
- * Effect of a helper: the fields it selects and the types of their values, or whether `map` converts its rows and what it gives, 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 {
-  /** Whether the helper guarantees that the query is grouped. */
-  readonly grouped: boolean;
-  readonly fields: object;
-  /** Types of the values of the fields it selects, the `fieldTypes` part of the state that its callback returns, which `having` and the narrowing of grouped selections read. */
-  readonly fieldTypes: unknown;
-  /** Whether `map` converts the rows, whose fields the result no longer tells, so that `fields` are empty. */
-  readonly mapped: boolean;
-  /** What `map` gives for each row of a query the helper is applied to; `never` when `mapped` is `false`. */
-  readonly output: unknown;
-  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 grouped: S["aggregate"] extends Grouped ? true : false;
-  readonly fields: S["value"] extends "mapped" ? EmptyRecord : { [K in keyof S["result"] as K extends keyof HelperFields ? never : K]: S["result"][K]; };
-  readonly fieldTypes: S["value"] extends "mapped" ? EmptyRecord : S["fieldTypes"];
-  readonly mapped: S["value"] extends "mapped" ? true : false;
-  readonly output: S["value"] extends "mapped" ? WithoutHelperFields<S["result"]> : never;
-  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 converts such records with `map`, or the error. */
-type CheckResult<S extends SelectQueryState> = [S] extends [{
-  readonly result: HelperFields;
-  readonly value: false;
-} | {
-  readonly value: "mapped";
-  readonly valueType: never;
-}] ? unknown : HelperError<"A helper can filter, select fields, map them, 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> & (true extends E["grouped"] ? {
-  readonly aggregate: false;
-} : unknown);
-/** 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] ? [E["mapped"]] extends [false] ? unknown : RecordRows<"A helper cannot apply map to a query made by get, pluck, an aggregate, or map"> : RecordRows<"A helper cannot apply nullable to a query made by get, pluck, an aggregate, or map"> : RecordRows<"A helper cannot select fields on a query made by get, pluck, an aggregate, or map">;
-/** 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> = ApplySelectionEffect<E["grouped"] extends true ? GroupedState<S> : S, E>;
-/** Applies the selected fields and row effects after the grouping guaranteed by the helper. */
-type ApplySelectionEffect<S extends SelectQueryState, E extends HelperEffect> = ChangeState<S, {
-  result: E["mapped"] extends true ? E["output"] : [keyof E["fields"]] extends [never] ? S["result"] : MergeSelection<S["result"], S["aggregate"] extends Grouped ? GroupedRecord<E["fields"], SelectedFieldTypesOf<E["fieldTypes"]>> : E["fields"]>;
-  fieldTypes: SelectedFieldTypes<S["fieldTypes"], SelectedFieldTypesOf<E["fieldTypes"]>>;
-  value: E["mapped"] extends true ? "mapped" : S["value"];
-  aggregate: E["mapped"] extends true ? true : S["aggregate"];
-  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`, an aggregate method, or `map` does not accept a helper that selects fields or maps them.
- * `use` of a mutation also applies a helper that only selects fields and maps them.
- */
-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, converts them with `map`, 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.
- * A helper that only selects fields and maps them also applies to an insert, an update, and a delete with their `use`, where it selects what they return; other methods fail there.
- */
-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>;
 /**
  * State in types of a query that inserts, updates, or deletes rows: its table and the relations of its schema, the rows mode of the rows it changes, and its result, which is their number until a selection returns their fields or `transform` converts it.
  *
@@ -2996,4 +3005,4 @@ declare function param<E extends AnyExpression, V extends (E extends AnyExpressi
  * A run of capital letters is one word, such as `user_id` for `userID`, and digits stay in their word, such as `line2`.
  */
 declare function toSnakeCase(key: string): string;
-export { NotAColumn as $, Type as $i, StringAggOptions as $n, CombinedCondition as $r, SchemaTables as $t, SqlQueryResult as A, QueryStateOf as Ai, greatest as An, ColumnValue as Ar, DeclaredRelations as At, createDatabase as B, ColumnValues as Bi, NestedQuery as Bn, SelectedOperandType as Br, RequiredMember as Bt, ResultByRows$1 as C, TypedScalarQuery as Ci, FollowingOperand as Cn, RelationRefs as Cr, DbQueryState as Ct, SessionOptions$1 as D, Grouped as Di, TypedOperandOperators as Dn, SelectQuery as Dr, SynchronousResult as Dt, ResultRows$1 as E, FoundKey as Ei, TypedOperandInput as En, ResultOf as Er, NotSynchronous as Et, TransactionConnectionError as F, AnyTable as Fi, GroupOperandValue as Fn, UpsertValues as Fr, RelationDeclaration as Ft, toSnakeCase as G, TableKeys as Gi, SelectionUses as Gn, NotAKey as Gr, UsableRelation as Gt, isOutcomeUnknown as H, Selectable as Hi, Selection as Hn, GroupTerm as Hr, SchemaRelations as Ht, TransactionOptions$1 as I, AnyTableKeys as Ii, GroupSelectionResult as In, FilteredStateRows as Ir, RelationDeclarations as It, param as J, createTableFactory as Ji, AggregateExpression as Jn, EqValue as Jr, one as Jt, SqlTemplate as K, TableOptions as Ki, Literal as Kn, PrimaryKeyColumn as Kr, UsedRelation as Kt, TypeOptions$1 as L, ColumnDefinitions as Li, GroupedField as Ln, FoundQueryState as Lr, RelationKey as Lt, SqlStatement$1 as M, SelectQueryState as Mi, ColumnFieldTypes as Mn, InsertValues as Mr, NoRelations as Mt, SqlValue as N, SingletonQueryState as Ni, ExpressionInput as Nn, UpdateSet as Nr, OneRelationKeys as Nt, SqlFragment$2 as O, InitialQueryState as Oi, caseWhen as On, SingletonInsertMany as Or, TransformedQuery as Ot, TextValue as P, TableQueryState as Pi, ExpressionValue as Pn, UpdateValues as Pr, Relation as Pt, MatchResult as Q, BaseType as Qi, GroupValue as Qn, WhereValues as Qr, SchemaPartRelations as Qt, TypeTransform$1 as R, ColumnOperators as Ri, GroupedRecord as Rn, FoundState as Rr, RelationKeys as Rt, QueryErrorCondition as S, ScalarQuery as Si, CaseValue as Sn, QueryContext as Sr, DbOf as St, ResultMode$1 as T, EmptyRecord as Ti, TypedOperand as Tn, BoundSelectQuery as Tr, AnyTransformedQuery as Tt, isQueryError as U, Table as Ui, SelectionFieldTypes as Un, GroupTerms as Ur, TableContext as Ut, createStatement$1 as V, KeyColumns as Vi, SelectedFieldTypes as Vn, RowLockOptions as Vr, SchemaContext as Vt, toDriverError as W, TableFactoryOptions as Wi, SelectionResult as Wn, KeyCheck as Wr, TableRelations as Wt, ColumnRefKey as X, RequiredRelationError as Xi, CountExpression as Xn, WhereCondition as Xr, Schema as Xt, sql as Y, defineTable as Yi, AggregateOptions as Yn, WhereCallback as Yr, AnySchema as Yt, MatchCheck as Z, AnyType as Zi, GroupAggregateExpression as Zn, WhereFilter as Zr, SchemaPart as Zt, OneRow$1 as _, ComparisonSignature as _i, Helper as _n, SelectedRefs as _r, UntypedExpression as _t, Database$1 as a, Column as aa, or as ai, SelectionState as an, every as ar, TextConversionSignature as at, QueryError as b, compare as bi, CaseBranch as bn, orderBy as br, Db as bt, DerivableType$1 as c, ToColumn as ca, QueryResult as ci, AnyMutationQuery as cn, some as cr, TextTypeOperators as ct, DriverErrorFields as d, NoOperators as da, EqualityOperator as di, ConflictTarget as dn, OrderColumns as dr, orderingOperators as dt, TypeInput as ea, Condition as ei, Tables as en, UnfilteredAggregateOptions as er, matches as et, DriverResult as f, OperatorDefinitions as fa, EqualityOperators as fi, InitialInsertState as fn, OrderDirection as fr, AnyExpression as ft, NotFoundError$1 as g, defineGenericOperator as ga, BooleanResult as gi, MutationQueryState as gn, Ordering as gr, TypedExpression as gt, IsolationLevel as h, OperatorSignature as ha, equalityOperators as hi, MutationQuery as hn, OrderTerms as hr, ExpressionOperators as ht, ConnectionError as i, AnyColumn as ia, not as ii, RecordQueryState as in, countDistinct as ir, PatternSignature as it, SqlQueryState as j, QueryValueType as ji, least as jn, ConflictUpdateSet as jr, MergeRelations as jt, SqlQuery$1 as k, QueryState as ki, coalesce as kn, from as kr, TransformedQueryState as kt, DerivableTypeWithParameters as l, BoundOperators as la, CountValueType as li, ConflictActionRequired as ln, stringAgg as lr, textOperators as lt, InitialSqlQueryState$1 as m, GenericOperatorImplementation as ma, InSignature as mi, InsertMutationState as mn, OrderTerm as mr, Expression as mt, BaseDerivableType as n, TypeOutput as na, Predicate as ni, AnyRecordQuery as nn, avg as nr, FALSE as nt, DatabaseOptions as o, ColumnAttributes as oa, ExistsValueType as oi, AnyQuery as on, max as or, TextLengthSignature as ot, FieldTypes as p, GenericOperator as pa, HasEquality as pi, InitialMutationState as pn, OrderKey as pr, BaseOperators as pt, identifier$1 as q, ToColumns as qi, literal as qn, PrimaryKeyValues as qr, many as qt, Connection as r, defineType$1 as ra, and as ri, RecordQuery as rn, count as rr, TRUE as rt, DecodedFields as s, KeyKind as sa, FilteredRows as si, SelectQueryKind as sn, min as sr, TextOperators as st, AnySqlQuery$1 as t, TypeOperators as ta, ConditionOperand as ti, defineSchema as tn, UnfilteredStringAggOptions as tr, defineExpression as tt, Driver as u, MergeOperators as ua, CompileOptions as ui, ConflictKeyRequired as un, sum as ur, NumberTypeOperators as ut, OneValueRows$1 as v, Operand as vi, HelperEffect as vn, asc as vr, AnyDb as vt, ResultDecodeError$1 as w, ValuesQuery as wi, NullSkippingResult as wn, AnySelectQuery as wr, bindSchema as wt, QueryErrorCode as x, OperandUses as xi, CaseCondition as xn, ColumnRefs as xr, DbMutationState as xt, PollLockOptions$1 as y, OperandValue as yi, defineHelper as yn, desc as yr, BindOptions as yt, ValueRows$1 as z, ColumnShape as zi, MergeSelection as zn, GroupedState as zr, RelationKind as zt };
+export { NotAColumn as $, BaseType as $i, avg as $n, WhereValues as $r, SchemaTables as $t, SqlQueryResult as A, QueryState as Ai, ExpressionInput as An, UpdateSet as Ar, DeclaredRelations as At, createDatabase as B, ColumnShape as Bi, SelectionFieldTypes as Bn, FoundState as Br, RequiredMember as Bt, ResultByRows$1 as C, ScalarQuery as Ci, TypedOperandInput as Cn, ResultOf as Cr, DbQueryState as Ct, SessionOptions$1 as D, FoundKey as Di, greatest as Dn, ColumnValue as Dr, SynchronousResult as Dt, ResultRows$1 as E, EmptyRecord as Ei, coalesce as En, from as Er, NotSynchronous as Et, TransactionConnectionError as F, TableQueryState as Fi, GroupedRecord as Fn, Helper as Fr, RelationDeclaration as Ft, toSnakeCase as G, TableFactoryOptions as Gi, AggregateExpression as Gn, KeyCheck as Gr, UsableRelation as Gt, isOutcomeUnknown as H, KeyColumns as Hi, SelectionUses as Hn, SelectedOperandType as Hr, SchemaRelations as Ht, TransactionOptions$1 as I, AnyTable as Ii, MergeSelection as In, HelperEffect as Ir, RelationDeclarations as It, param as J, ToColumns as Ji, GroupAggregateExpression as Jn, PrimaryKeyValues as Jr, one as Jt, SqlTemplate as K, TableKeys as Ki, AggregateOptions as Kn, NotAKey as Kr, UsedRelation as Kt, TypeOptions$1 as L, AnyTableKeys as Li, NestedQuery as Ln, defineHelper as Lr, RelationKey as Lt, SqlStatement$1 as M, QueryValueType as Mi, GroupOperandValue as Mn, UpsertValues as Mr, NoRelations as Mt, SqlValue as N, SelectQueryState as Ni, GroupSelectionResult as Nn, RowLockOptions as Nr, OneRelationKeys as Nt, SqlFragment$2 as O, Grouped as Oi, least as On, ConflictUpdateSet as Or, TransformedQuery as Ot, TextValue as P, SingletonQueryState as Pi, GroupedField as Pn, AnyHelper as Pr, Relation as Pt, MatchResult as Q, AnyType as Qi, UnfilteredStringAggOptions as Qn, WhereFilter as Qr, SchemaPartRelations as Qt, TypeTransform$1 as R, ColumnDefinitions as Ri, SelectedFieldTypes as Rn, FilteredStateRows as Rr, RelationKeys as Rt, QueryErrorCondition as S, OperandUses as Si, TypedOperand as Sn, BoundSelectQuery as Sr, DbOf as St, ResultMode$1 as T, ValuesQuery as Ti, caseWhen as Tn, SingletonInsertMany as Tr, AnyTransformedQuery as Tt, isQueryError as U, Selectable as Ui, Literal as Un, GroupTerm as Ur, TableContext as Ut, createStatement$1 as V, ColumnValues as Vi, SelectionResult as Vn, GroupedState as Vr, SchemaContext as Vt, toDriverError as W, Table as Wi, literal as Wn, GroupTerms as Wr, TableRelations as Wt, ColumnRefKey as X, defineTable as Xi, StringAggOptions as Xn, WhereCallback as Xr, Schema as Xt, sql as Y, createTableFactory as Yi, GroupValue as Yn, EqValue as Yr, AnySchema as Yt, MatchCheck as Z, RequiredRelationError as Zi, UnfilteredAggregateOptions as Zn, WhereCondition as Zr, SchemaPart as Zt, OneRow$1 as _, defineGenericOperator as _a, BooleanResult as _i, CaseBranch as _n, orderBy as _r, UntypedExpression as _t, Database$1 as a, AnyColumn as aa, not as ai, SelectionState as an, some as ar, TextConversionSignature as at, QueryError as b, OperandValue as bi, FollowingOperand as bn, RelationRefs as br, Db as bt, DerivableType$1 as c, KeyKind as ca, FilteredRows as ci, AnyMutationQuery as cn, OrderColumns as cr, TextTypeOperators as ct, DriverErrorFields as d, MergeOperators as da, CompileOptions as di, ConflictTarget as dn, OrderTerm as dr, orderingOperators as dt, Type as ea, CombinedCondition as ei, Tables as en, count as er, matches as et, DriverResult as f, NoOperators as fa, EqualityOperator as fi, InitialInsertState as fn, OrderTerms as fr, AnyExpression as ft, NotFoundError$1 as g, OperatorSignature as ga, equalityOperators as gi, MutationQueryState as gn, desc as gr, TypedExpression as gt, IsolationLevel as h, GenericOperatorImplementation as ha, InSignature as hi, MutationQuery as hn, asc as hr, ExpressionOperators as ht, ConnectionError as i, defineType$1 as ia, and as ii, RecordQueryState as in, min as ir, PatternSignature as it, SqlQueryState as j, QueryStateOf as ji, ExpressionValue as jn, UpdateValues as jr, MergeRelations as jt, SqlQuery$1 as k, InitialQueryState as ki, ColumnFieldTypes as kn, InsertValues as kr, TransformedQueryState as kt, DerivableTypeWithParameters as l, ToColumn as la, QueryResult as li, ConflictActionRequired as ln, OrderDirection as lr, textOperators as lt, InitialSqlQueryState$1 as m, GenericOperator as ma, HasEquality as mi, InsertMutationState as mn, SelectedRefs as mr, Expression as mt, BaseDerivableType as n, TypeOperators as na, ConditionOperand as ni, AnyRecordQuery as nn, every as nr, FALSE as nt, DatabaseOptions as o, Column as oa, or as oi, AnyQuery as on, stringAgg as or, TextLengthSignature as ot, FieldTypes as p, OperatorDefinitions as pa, EqualityOperators as pi, InitialMutationState as pn, Ordering as pr, BaseOperators as pt, identifier$1 as q, TableOptions as qi, CountExpression as qn, PrimaryKeyColumn as qr, many as qt, Connection as r, TypeOutput as ra, Predicate as ri, RecordQuery as rn, max as rr, TRUE as rt, DecodedFields as s, ColumnAttributes as sa, ExistsValueType as si, SelectQueryKind as sn, sum as sr, TextOperators as st, AnySqlQuery$1 as t, TypeInput as ta, Condition as ti, defineSchema as tn, countDistinct as tr, defineExpression as tt, Driver as u, BoundOperators as ua, CountValueType as ui, ConflictKeyRequired as un, OrderKey as ur, NumberTypeOperators as ut, OneValueRows$1 as v, ComparisonSignature as vi, CaseCondition as vn, ColumnRefs as vr, AnyDb as vt, ResultDecodeError$1 as w, TypedScalarQuery as wi, TypedOperandOperators as wn, SelectQuery as wr, bindSchema as wt, QueryErrorCode as x, compare as xi, NullSkippingResult as xn, AnySelectQuery as xr, DbMutationState as xt, PollLockOptions$1 as y, Operand as yi, CaseValue as yn, QueryContext as yr, BindOptions as yt, ValueRows$1 as z, ColumnOperators as zi, Selection as zn, FoundQueryState as zr, RelationKind as zt };

package/dist/index.d.mts

@@ -1,2 +1,2 @@
-import { $ as NotAColumn, $i as Type, $n as StringAggOptions, $r as CombinedCondition, $t as SchemaTables, A as SqlQueryResult, Ai as QueryStateOf, An as greatest, Ar as ColumnValue, At as DeclaredRelations, B as createDatabase, Bi as ColumnValues, Bn as NestedQuery, Br as SelectedOperandType, Bt as RequiredMember, C as ResultByRows, Ci as TypedScalarQuery, Cn as FollowingOperand, Cr as RelationRefs, Ct as DbQueryState, D as SessionOptions, Di as Grouped, Dn as TypedOperandOperators, Dr as SelectQuery, Dt as SynchronousResult, E as ResultRows, Ei as FoundKey, En as TypedOperandInput, Er as ResultOf, Et as NotSynchronous, F as TransactionConnectionError, Fi as AnyTable, Fn as GroupOperandValue, Fr as UpsertValues, Ft as RelationDeclaration, G as toSnakeCase, Gi as TableKeys, Gn as SelectionUses, Gr as NotAKey, Gt as UsableRelation, H as isOutcomeUnknown, Hi as Selectable, Hn as Selection, Hr as GroupTerm, Ht as SchemaRelations, I as TransactionOptions, Ii as AnyTableKeys, In as GroupSelectionResult, Ir as FilteredStateRows, It as RelationDeclarations, J as param, Ji as createTableFactory, Jn as AggregateExpression, Jr as EqValue, Jt as one, K as SqlTemplate, Ki as TableOptions, Kn as Literal, Kr as PrimaryKeyColumn, Kt as UsedRelation, L as TypeOptions, Li as ColumnDefinitions, Ln as GroupedField, Lr as FoundQueryState, Lt as RelationKey, M as SqlStatement, Mi as SelectQueryState, Mn as ColumnFieldTypes, Mr as InsertValues, Mt as NoRelations, N as SqlValue, Ni as SingletonQueryState, Nn as ExpressionInput, Nr as UpdateSet, Nt as OneRelationKeys, O as SqlFragment, Oi as InitialQueryState, On as caseWhen, Or as SingletonInsertMany, Ot as TransformedQuery, P as TextValue, Pi as TableQueryState, Pn as ExpressionValue, Pr as UpdateValues, Pt as Relation, Q as MatchResult, Qi as BaseType, Qn as GroupValue, Qr as WhereValues, Qt as SchemaPartRelations, R as TypeTransform, Ri as ColumnOperators, Rn as GroupedRecord, Rr as FoundState, Rt as RelationKeys, S as QueryErrorCondition, Si as ScalarQuery, Sn as CaseValue, Sr as QueryContext, St as DbOf, T as ResultMode, Ti as EmptyRecord, Tn as TypedOperand, Tr as BoundSelectQuery, Tt as AnyTransformedQuery, U as isQueryError, Ui as Table, Un as SelectionFieldTypes, Ur as GroupTerms, Ut as TableContext, V as createStatement, Vi as KeyColumns, Vn as SelectedFieldTypes, Vr as RowLockOptions, Vt as SchemaContext, W as toDriverError, Wi as TableFactoryOptions, Wn as SelectionResult, Wr as KeyCheck, Wt as TableRelations, X as ColumnRefKey, Xi as RequiredRelationError, Xn as CountExpression, Xr as WhereCondition, Xt as Schema, Y as sql, Yi as defineTable, Yn as AggregateOptions, Yr as WhereCallback, Yt as AnySchema, Z as MatchCheck, Zi as AnyType, Zn as GroupAggregateExpression, Zr as WhereFilter, Zt as SchemaPart, _ as OneRow, _i as ComparisonSignature, _n as Helper, _r as SelectedRefs, _t as UntypedExpression, a as Database, aa as Column, ai as or, an as SelectionState, ar as every, at as TextConversionSignature, b as QueryError, bi as compare, bn as CaseBranch, br as orderBy, bt as Db, c as DerivableType, ca as ToColumn, ci as QueryResult, cn as AnyMutationQuery, cr as some, ct as TextTypeOperators, d as DriverErrorFields, da as NoOperators, di as EqualityOperator, dn as ConflictTarget, dr as OrderColumns, dt as orderingOperators, ea as TypeInput, ei as Condition, en as Tables, er as UnfilteredAggregateOptions, et as matches, f as DriverResult, fa as OperatorDefinitions, fi as EqualityOperators, fn as InitialInsertState, fr as OrderDirection, ft as AnyExpression, g as NotFoundError, ga as defineGenericOperator, gi as BooleanResult, gn as MutationQueryState, gr as Ordering, gt as TypedExpression, h as IsolationLevel, ha as OperatorSignature, hi as equalityOperators, hn as MutationQuery, hr as OrderTerms, ht as ExpressionOperators, i as ConnectionError, ia as AnyColumn, ii as not, in as RecordQueryState, ir as countDistinct, it as PatternSignature, j as SqlQueryState, ji as QueryValueType, jn as least, jr as ConflictUpdateSet, jt as MergeRelations, k as SqlQuery, ki as QueryState, kn as coalesce, kr as from, kt as TransformedQueryState, l as DerivableTypeWithParameters, la as BoundOperators, li as CountValueType, ln as ConflictActionRequired, lr as stringAgg, lt as textOperators, m as InitialSqlQueryState, ma as GenericOperatorImplementation, mi as InSignature, mn as InsertMutationState, mr as OrderTerm, mt as Expression, n as BaseDerivableType, na as TypeOutput, ni as Predicate, nn as AnyRecordQuery, nr as avg, nt as FALSE, o as DatabaseOptions, oa as ColumnAttributes, oi as ExistsValueType, on as AnyQuery, or as max, ot as TextLengthSignature, p as FieldTypes, pa as GenericOperator, pi as HasEquality, pn as InitialMutationState, pr as OrderKey, pt as BaseOperators, q as identifier, qi as ToColumns, qn as literal, qr as PrimaryKeyValues, qt as many, r as Connection, ra as defineType, ri as and, rn as RecordQuery, rr as count, rt as TRUE, s as DecodedFields, sa as KeyKind, si as FilteredRows, sn as SelectQueryKind, sr as min, st as TextOperators, t as AnySqlQuery, ta as TypeOperators, ti as ConditionOperand, tn as defineSchema, tr as UnfilteredStringAggOptions, tt as defineExpression, u as Driver, ua as MergeOperators, ui as CompileOptions, un as ConflictKeyRequired, ur as sum, ut as NumberTypeOperators, v as OneValueRows, vi as Operand, vn as HelperEffect, vr as asc, vt as AnyDb, w as ResultDecodeError, wi as ValuesQuery, wn as NullSkippingResult, wr as AnySelectQuery, wt as bindSchema, x as QueryErrorCode, xi as OperandUses, xn as CaseCondition, xr as ColumnRefs, xt as DbMutationState, y as PollLockOptions, yi as OperandValue, yn as defineHelper, yr as desc, yt as BindOptions, z as ValueRows, zi as ColumnShape, zn as MergeSelection, zr as GroupedState, zt as RelationKind } from "./index-Cv9QJ_v7.mjs";
-export { type AggregateExpression, type AggregateOptions, type AnyColumn, type AnyDb, type AnyExpression, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyTransformedQuery, type AnyType, type BaseDerivableType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnFieldTypes, type ColumnOperators, type ColumnRefKey, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type ConflictActionRequired, type ConflictKeyRequired, type ConflictTarget, type ConflictUpdateSet, type Connection, ConnectionError, type CountExpression, type CountValueType, type Database, type DatabaseOptions, type Db, type DbMutationState, type DbOf, type DbQueryState, type DeclaredRelations, type DecodedFields, type DerivableType, type DerivableTypeWithParameters, type Driver, type DriverErrorFields, type DriverResult, type EmptyRecord, type EqValue, type EqualityOperator, type EqualityOperators, type ExistsValueType, type Expression, type ExpressionInput, type ExpressionOperators, type ExpressionValue, FALSE, type FieldTypes, type FilteredRows, type FilteredStateRows, type FollowingOperand, type FoundKey, type FoundQueryState, type FoundState, type GenericOperator, type GenericOperatorImplementation, type GroupAggregateExpression, type GroupOperandValue, type GroupSelectionResult, type GroupTerm, type GroupTerms, type GroupValue, type Grouped, type GroupedField, type GroupedRecord, type GroupedState, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialInsertState, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertMutationState, type InsertValues, type IsolationLevel, type KeyCheck, type KeyColumns, type KeyKind, type Literal, type MatchCheck, type MatchResult, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAColumn, type NotAKey, NotFoundError, type NotSynchronous, type NullSkippingResult, type NumberTypeOperators, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, type OperandUses, type OperandValue, type OperatorDefinitions, type OperatorSignature, type OrderColumns, type OrderDirection, type OrderKey, type OrderTerm, type OrderTerms, type Ordering, type PatternSignature, type PollLockOptions, type Predicate, type PrimaryKeyColumn, type PrimaryKeyValues, type QueryContext, QueryError, type QueryErrorCode, type QueryErrorCondition, type QueryResult, type QueryState, type QueryStateOf, type QueryValueType, type RecordQuery, type RecordQueryState, type Relation, type RelationDeclaration, type RelationDeclarations, type RelationKey, type RelationKeys, type RelationKind, type RelationRefs, type RequiredMember, RequiredRelationError, type ResultByRows, ResultDecodeError, type ResultMode, type ResultOf, type ResultRows, type RowLockOptions, type ScalarQuery, type Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedFieldTypes, type SelectedOperandType, type SelectedRefs, type Selection, type SelectionFieldTypes, type SelectionResult, type SelectionState, type SelectionUses, type SessionOptions, type SingletonInsertMany, type SingletonQueryState, type SqlFragment, type SqlQuery, type SqlQueryResult, type SqlQueryState, type SqlStatement, type SqlTemplate, type SqlValue, type StringAggOptions, type SynchronousResult, TRUE, type Table, type TableContext, type TableFactoryOptions, type TableKeys, type TableOptions, type TableQueryState, type TableRelations, type Tables, type TextConversionSignature, type TextLengthSignature, type TextOperators, type TextTypeOperators, type TextValue, type ToColumn, type ToColumns, TransactionConnectionError, type TransactionOptions, type TransformedQuery, type TransformedQueryState, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UnfilteredAggregateOptions, type UnfilteredStringAggOptions, type UntypedExpression, type UpdateSet, type UpdateValues, type UpsertValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, and, asc, avg, bindSchema, caseWhen, coalesce, compare, count, countDistinct, createDatabase, createStatement, createTableFactory, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, every, from, greatest, identifier, isOutcomeUnknown, isQueryError, least, literal, many, matches, max, min, not, one, or, orderBy, orderingOperators, param, some, sql, stringAgg, sum, textOperators, toDriverError, toSnakeCase };
+import { $ as NotAColumn, $i as BaseType, $n as avg, $r as WhereValues, $t as SchemaTables, A as SqlQueryResult, Ai as QueryState, An as ExpressionInput, Ar as UpdateSet, At as DeclaredRelations, B as createDatabase, Bi as ColumnShape, Bn as SelectionFieldTypes, Br as FoundState, Bt as RequiredMember, C as ResultByRows, Ci as ScalarQuery, Cn as TypedOperandInput, Cr as ResultOf, Ct as DbQueryState, D as SessionOptions, Di as FoundKey, Dn as greatest, Dr as ColumnValue, Dt as SynchronousResult, E as ResultRows, Ei as EmptyRecord, En as coalesce, Er as from, Et as NotSynchronous, F as TransactionConnectionError, Fi as TableQueryState, Fn as GroupedRecord, Fr as Helper, Ft as RelationDeclaration, G as toSnakeCase, Gi as TableFactoryOptions, Gn as AggregateExpression, Gr as KeyCheck, Gt as UsableRelation, H as isOutcomeUnknown, Hi as KeyColumns, Hn as SelectionUses, Hr as SelectedOperandType, Ht as SchemaRelations, I as TransactionOptions, Ii as AnyTable, In as MergeSelection, Ir as HelperEffect, It as RelationDeclarations, J as param, Ji as ToColumns, Jn as GroupAggregateExpression, Jr as PrimaryKeyValues, Jt as one, K as SqlTemplate, Ki as TableKeys, Kn as AggregateOptions, Kr as NotAKey, Kt as UsedRelation, L as TypeOptions, Li as AnyTableKeys, Ln as NestedQuery, Lr as defineHelper, Lt as RelationKey, M as SqlStatement, Mi as QueryValueType, Mn as GroupOperandValue, Mr as UpsertValues, Mt as NoRelations, N as SqlValue, Ni as SelectQueryState, Nn as GroupSelectionResult, Nr as RowLockOptions, Nt as OneRelationKeys, O as SqlFragment, Oi as Grouped, On as least, Or as ConflictUpdateSet, Ot as TransformedQuery, P as TextValue, Pi as SingletonQueryState, Pn as GroupedField, Pr as AnyHelper, Pt as Relation, Q as MatchResult, Qi as AnyType, Qn as UnfilteredStringAggOptions, Qr as WhereFilter, Qt as SchemaPartRelations, R as TypeTransform, Ri as ColumnDefinitions, Rn as SelectedFieldTypes, Rr as FilteredStateRows, Rt as RelationKeys, S as QueryErrorCondition, Si as OperandUses, Sn as TypedOperand, Sr as BoundSelectQuery, St as DbOf, T as ResultMode, Ti as ValuesQuery, Tn as caseWhen, Tr as SingletonInsertMany, Tt as AnyTransformedQuery, U as isQueryError, Ui as Selectable, Un as Literal, Ur as GroupTerm, Ut as TableContext, V as createStatement, Vi as ColumnValues, Vn as SelectionResult, Vr as GroupedState, Vt as SchemaContext, W as toDriverError, Wi as Table, Wn as literal, Wr as GroupTerms, Wt as TableRelations, X as ColumnRefKey, Xi as defineTable, Xn as StringAggOptions, Xr as WhereCallback, Xt as Schema, Y as sql, Yi as createTableFactory, Yn as GroupValue, Yr as EqValue, Yt as AnySchema, Z as MatchCheck, Zi as RequiredRelationError, Zn as UnfilteredAggregateOptions, Zr as WhereCondition, Zt as SchemaPart, _ as OneRow, _a as defineGenericOperator, _i as BooleanResult, _n as CaseBranch, _r as orderBy, _t as UntypedExpression, a as Database, aa as AnyColumn, ai as not, an as SelectionState, ar as some, at as TextConversionSignature, b as QueryError, bi as OperandValue, bn as FollowingOperand, br as RelationRefs, bt as Db, c as DerivableType, ca as KeyKind, ci as FilteredRows, cn as AnyMutationQuery, cr as OrderColumns, ct as TextTypeOperators, d as DriverErrorFields, da as MergeOperators, di as CompileOptions, dn as ConflictTarget, dr as OrderTerm, dt as orderingOperators, ea as Type, ei as CombinedCondition, en as Tables, er as count, et as matches, f as DriverResult, fa as NoOperators, fi as EqualityOperator, fn as InitialInsertState, fr as OrderTerms, ft as AnyExpression, g as NotFoundError, ga as OperatorSignature, gi as equalityOperators, gn as MutationQueryState, gr as desc, gt as TypedExpression, h as IsolationLevel, ha as GenericOperatorImplementation, hi as InSignature, hn as MutationQuery, hr as asc, ht as ExpressionOperators, i as ConnectionError, ia as defineType, ii as and, in as RecordQueryState, ir as min, it as PatternSignature, j as SqlQueryState, ji as QueryStateOf, jn as ExpressionValue, jr as UpdateValues, jt as MergeRelations, k as SqlQuery, ki as InitialQueryState, kn as ColumnFieldTypes, kr as InsertValues, kt as TransformedQueryState, l as DerivableTypeWithParameters, la as ToColumn, li as QueryResult, ln as ConflictActionRequired, lr as OrderDirection, lt as textOperators, m as InitialSqlQueryState, ma as GenericOperator, mi as HasEquality, mn as InsertMutationState, mr as SelectedRefs, mt as Expression, n as BaseDerivableType, na as TypeOperators, ni as ConditionOperand, nn as AnyRecordQuery, nr as every, nt as FALSE, o as DatabaseOptions, oa as Column, oi as or, on as AnyQuery, or as stringAgg, ot as TextLengthSignature, p as FieldTypes, pa as OperatorDefinitions, pi as EqualityOperators, pn as InitialMutationState, pr as Ordering, pt as BaseOperators, q as identifier, qi as TableOptions, qn as CountExpression, qr as PrimaryKeyColumn, qt as many, r as Connection, ra as TypeOutput, ri as Predicate, rn as RecordQuery, rr as max, rt as TRUE, s as DecodedFields, sa as ColumnAttributes, si as ExistsValueType, sn as SelectQueryKind, sr as sum, st as TextOperators, t as AnySqlQuery, ta as TypeInput, ti as Condition, tn as defineSchema, tr as countDistinct, tt as defineExpression, u as Driver, ua as BoundOperators, ui as CountValueType, un as ConflictKeyRequired, ur as OrderKey, ut as NumberTypeOperators, v as OneValueRows, vi as ComparisonSignature, vn as CaseCondition, vr as ColumnRefs, vt as AnyDb, w as ResultDecodeError, wi as TypedScalarQuery, wn as TypedOperandOperators, wr as SelectQuery, wt as bindSchema, x as QueryErrorCode, xi as compare, xn as NullSkippingResult, xr as AnySelectQuery, xt as DbMutationState, y as PollLockOptions, yi as Operand, yn as CaseValue, yr as QueryContext, yt as BindOptions, z as ValueRows, zi as ColumnOperators, zn as Selection, zr as FoundQueryState, zt as RelationKind } from "./index-CFkH9TlC.mjs";
+export { type AggregateExpression, type AggregateOptions, type AnyColumn, type AnyDb, type AnyExpression, type AnyHelper, type AnyMutationQuery, type AnyQuery, type AnyRecordQuery, type AnySchema, type AnySelectQuery, type AnySqlQuery, type AnyTable, type AnyTableKeys, type AnyTransformedQuery, type AnyType, type BaseDerivableType, type BaseOperators, type BaseType, type BindOptions, type BooleanResult, type BoundOperators, type BoundSelectQuery, type CaseBranch, type CaseCondition, type CaseValue, type Column, type ColumnAttributes, type ColumnDefinitions, type ColumnFieldTypes, type ColumnOperators, type ColumnRefKey, type ColumnRefs, type ColumnShape, type ColumnValue, type ColumnValues, type CombinedCondition, type ComparisonSignature, type CompileOptions, type Condition, type ConditionOperand, type ConflictActionRequired, type ConflictKeyRequired, type ConflictTarget, type ConflictUpdateSet, type Connection, ConnectionError, type CountExpression, type CountValueType, type Database, type DatabaseOptions, type Db, type DbMutationState, type DbOf, type DbQueryState, type DeclaredRelations, type DecodedFields, type DerivableType, type DerivableTypeWithParameters, type Driver, type DriverErrorFields, type DriverResult, type EmptyRecord, type EqValue, type EqualityOperator, type EqualityOperators, type ExistsValueType, type Expression, type ExpressionInput, type ExpressionOperators, type ExpressionValue, FALSE, type FieldTypes, type FilteredRows, type FilteredStateRows, type FollowingOperand, type FoundKey, type FoundQueryState, type FoundState, type GenericOperator, type GenericOperatorImplementation, type GroupAggregateExpression, type GroupOperandValue, type GroupSelectionResult, type GroupTerm, type GroupTerms, type GroupValue, type Grouped, type GroupedField, type GroupedRecord, type GroupedState, type HasEquality, type Helper, type HelperEffect, type InSignature, type InitialInsertState, type InitialMutationState, type InitialQueryState, type InitialSqlQueryState, type InsertMutationState, type InsertValues, type IsolationLevel, type KeyCheck, type KeyColumns, type KeyKind, type Literal, type MatchCheck, type MatchResult, type MergeOperators, type MergeRelations, type MergeSelection, type MutationQuery, type MutationQueryState, type NestedQuery, type NoOperators, type NoRelations, type NotAColumn, type NotAKey, NotFoundError, type NotSynchronous, type NullSkippingResult, type NumberTypeOperators, type OneRelationKeys, type OneRow, type OneValueRows, type Operand, type OperandUses, type OperandValue, type OperatorDefinitions, type OperatorSignature, type OrderColumns, type OrderDirection, type OrderKey, type OrderTerm, type OrderTerms, type Ordering, type PatternSignature, type PollLockOptions, type Predicate, type PrimaryKeyColumn, type PrimaryKeyValues, type QueryContext, QueryError, type QueryErrorCode, type QueryErrorCondition, type QueryResult, type QueryState, type QueryStateOf, type QueryValueType, type RecordQuery, type RecordQueryState, type Relation, type RelationDeclaration, type RelationDeclarations, type RelationKey, type RelationKeys, type RelationKind, type RelationRefs, type RequiredMember, RequiredRelationError, type ResultByRows, ResultDecodeError, type ResultMode, type ResultOf, type ResultRows, type RowLockOptions, type ScalarQuery, type Schema, type SchemaContext, type SchemaPart, type SchemaPartRelations, type SchemaRelations, type SchemaTables, type SelectQuery, type SelectQueryKind, type SelectQueryState, type Selectable, type SelectedFieldTypes, type SelectedOperandType, type SelectedRefs, type Selection, type SelectionFieldTypes, type SelectionResult, type SelectionState, type SelectionUses, type SessionOptions, type SingletonInsertMany, type SingletonQueryState, type SqlFragment, type SqlQuery, type SqlQueryResult, type SqlQueryState, type SqlStatement, type SqlTemplate, type SqlValue, type StringAggOptions, type SynchronousResult, TRUE, type Table, type TableContext, type TableFactoryOptions, type TableKeys, type TableOptions, type TableQueryState, type TableRelations, type Tables, type TextConversionSignature, type TextLengthSignature, type TextOperators, type TextTypeOperators, type TextValue, type ToColumn, type ToColumns, TransactionConnectionError, type TransactionOptions, type TransformedQuery, type TransformedQueryState, type Type, type TypeInput, type TypeOperators, type TypeOptions, type TypeOutput, type TypeTransform, type TypedExpression, type TypedOperand, type TypedOperandInput, type TypedOperandOperators, type TypedScalarQuery, type UnfilteredAggregateOptions, type UnfilteredStringAggOptions, type UntypedExpression, type UpdateSet, type UpdateValues, type UpsertValues, type UsableRelation, type UsedRelation, type ValueRows, type ValuesQuery, type WhereCallback, type WhereCondition, type WhereFilter, type WhereValues, and, asc, avg, bindSchema, caseWhen, coalesce, compare, count, countDistinct, createDatabase, createStatement, createTableFactory, defineExpression, defineGenericOperator, defineHelper, defineSchema, defineTable, defineType, desc, equalityOperators, every, from, greatest, identifier, isOutcomeUnknown, isQueryError, least, literal, many, matches, max, min, not, one, or, orderBy, orderingOperators, param, some, sql, stringAgg, sum, textOperators, toDriverError, toSnakeCase };

package/dist/types.d.mts

@@ -1,4 +1,4 @@
-import { $i as Type, Qi as BaseType, _i as ComparisonSignature, aa as Column, ct as TextTypeOperators, da as NoOperators, di as EqualityOperator, fa as OperatorDefinitions, fi as EqualityOperators, ft as AnyExpression, mi as InSignature, pa as GenericOperator, pi as HasEquality, st as TextOperators, ua as MergeOperators, ut as NumberTypeOperators } from "./index-Cv9QJ_v7.mjs";
+import { $i as BaseType, ct as TextTypeOperators, da as MergeOperators, ea as Type, fa as NoOperators, fi as EqualityOperator, ft as AnyExpression, hi as InSignature, ma as GenericOperator, mi as HasEquality, oa as Column, pa as OperatorDefinitions, pi as EqualityOperators, st as TextOperators, ut as NumberTypeOperators, vi as ComparisonSignature } from "./index-CFkH9TlC.mjs";
 /**
  * Creates a one-dimensional array type of `element` values.
  *
@@ -71,7 +71,10 @@ declare function enumOf<const Values extends readonly string[]>(name: string, va
   gt: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
   gte: GenericOperator<ComparisonSignature, AnyExpression<unknown, unknown>>;
 }>, undefined>;
-/** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
+/**
+ * `json` values; `json.of<T>()` declares their shape.
+ * PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`.
+ */
 export declare const json: BaseType<unknown, {}, NoOperators, undefined>;
 /** `jsonb` values; `jsonb.of<T>()` declares their shape. */
 export declare const jsonb: BaseType<unknown, {}, MergeOperators<NoOperators, EqualityOperators>, undefined>;

package/dist/types.mjs

@@ -35,7 +35,10 @@ function enumOf(name, values) {
 	return defineType(dbTypes.enum(name, values)).withOperators(orderingOperators);
 }
 // src/type/builtins/json.ts
-/** `json` values; `json.of<T>()` declares their shape. PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`. */
+/**
+* `json` values; `json.of<T>()` declares their shape.
+* PostgreSQL has no `=` for `json`, so its expressions have no `eq`, `ne`, or `in`.
+*/
 const json = /* @__PURE__ */ defineType(dbTypes.json);
 /** `jsonb` values; `jsonb.of<T>()` declares their shape. */
 const jsonb = /* @__PURE__ */ defineType(dbTypes.jsonb).withOperators(equalityOperators);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kern-orm",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Fully typed relational query builder for PostgreSQL with ambient transactions and single-query relation loading",
   "keywords": [
     "orm",
@@ -45,7 +45,7 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "kern-db": "^0.4.0"
+    "kern-db": "^0.5.0"
   },
   "devDependencies": {
     "@kern-orm/test-harness": "workspace:*",