joist-core 2.4.0-next.37 → 2.4.0-next.39

package/build/queries/sql/query.d.cts

@@ -43,11 +43,11 @@ import { Entity } from "../../Entity.cjs";
  *
  * User documentation: `docs/src/content/docs/features/queries-raw.md`.
  */
-declare const subqueryBrand: unique symbol;
-declare const entityQueryBrand: unique symbol;
-declare const scalarQueryBrand: unique symbol;
+export declare const subqueryBrand: unique symbol;
+export declare const entityQueryBrand: unique symbol;
+export declare const scalarQueryBrand: unique symbol;
 /** A query(...) value with any projection, for EXISTS and NOT EXISTS predicates. */
-type ExistsQuery = QueryTable<unknown, string> | EntityQuery<Entity> | {
+export type ExistsQuery = QueryTable<unknown, string> | EntityQuery<Entity> | {
   readonly [scalarQueryBrand]: true;
 };
 /**
@@ -57,7 +57,7 @@ type ExistsQuery = QueryTable<unknown, string> | EntityQuery<Entity> | {
  * I.e. `{ and: [a.age.gte(18), { exists: booksForAuthor }] }` selects adult Authors with Books,
  * where `booksForAuthor` is `query({ from: b, where: b.author_id.eq(a.id), select: b.id })`.
  */
-type QueryCondition = SqlPredicate | UnbrandedPredicate | (({
+export type QueryCondition = SqlPredicate | UnbrandedPredicate | (({
   and: readonly (QueryCondition | undefined)[];
   or?: never;
   exists?: never;
@@ -81,14 +81,14 @@ type QueryCondition = SqlPredicate | UnbrandedPredicate | (({
   or?: never;
 };
 /** Phantom type information carried by a table-shaped `query(...)` value. */
-interface QueryTableBrand<R, Name extends string> {
+export interface QueryTableBrand<R, Name extends string> {
   readonly __row: R;
   readonly __name: Name;
 }
 /** @deprecated Renamed to `QueryTableBrand`; a `query(...)` value is a table shape, not only a subquery. */
-type SubqueryBrand<R, Name extends string> = QueryTableBrand<R, Name>;
+export type SubqueryBrand<R, Name extends string> = QueryTableBrand<R, Name>;
 /** Anything that can be a source or be joined: an entity table or a table-shaped subquery. */
-type QuerySource = {
+export type QuerySource = {
   readonly [tableMgmt]: TableSourceBrand<string>;
 } | {
   readonly [subqueryBrand]: QueryTableBrand<any, string>;
@@ -104,36 +104,36 @@ type SelectableQuerySource = {
  * entry a relation join factory returns (`a.books.as(b)`); joins to a subquery are always the expanded
  * form, since a subquery has no FK metadata.
  */
-type QueryJoin = InnerJoin<QuerySource, QueryCondition> | LeftJoin<QuerySource, QueryCondition>;
-type QueryJoinList = readonly (QueryJoin | undefined)[];
+export type QueryJoin = InnerJoin<QuerySource, QueryCondition> | LeftJoin<QuerySource, QueryCondition>;
+export type QueryJoinList = readonly (QueryJoin | undefined)[];
 /** A flat SQL join list or a domain relationship tree rooted at from. */
-type QueryJoinInput = QueryJoinList | Readonly<Record<string, unknown>>;
+export type QueryJoinInput = QueryJoinList | Readonly<Record<string, unknown>>;
 /**
  * Resolves tree bindings to join types for scope and result nullability.
  * Deferring the extracted entry union avoids expanding recursive constraints in generic query signatures.
  */
-type ResolvedJoins<F, J> = J extends QueryJoinList ? J : F extends TableFor<infer T extends Entity> ? TreeEntries<T, J> extends (infer E) ? readonly Extract<E, QueryJoin>[] : never : [];
+export type ResolvedJoins<F, J> = J extends QueryJoinList ? J : F extends TableFor<infer T extends Entity> ? TreeEntries<T, J> extends (infer E) ? readonly Extract<E, QueryJoin>[] : never : [];
 /**
  * A CTE declaration: a `query(...)` value with named columns, i.e. a POJO or set-operation select.
  *
  * Entity-mode and scalar `query(...)` shapes are excluded: a CTE must be a table shape, so it needs
  * columns.
  */
-type WithSource = QueryTable<unknown, string>;
+export type WithSource = QueryTable<unknown, string>;
 /** One CTE or an array of them; an `undefined` entry prunes, like any other clause. */
-type WithInput = WithSource | readonly (WithSource | undefined)[];
+export type WithInput = WithSource | readonly (WithSource | undefined)[];
 /** How a recursive CTE combines its two terms: `UNION ALL` keeps every row, `UNION` drops duplicates. */
-interface RecursiveOptions {
+export interface RecursiveOptions {
   /** Defaults to `"all"`. `"distinct"` emits UNION, which stops a cyclic graph from looping forever. */
   union?: "all" | "distinct";
 }
 /** An expression order-by entry, also returned by `expr.asc()` and `expr.desc()`. An undefined order prunes it. */
-type ExpressionOrderBy = {
+export type ExpressionOrderBy = {
   readonly sort: ExprLike<unknown>;
   readonly order: "ASC" | "DESC" | undefined;
   readonly nulls?: "first" | "last";
 };
-type OrderByDirection = "ASC" | "DESC" | "ASC NULLS FIRST" | "ASC NULLS LAST" | "DESC NULLS FIRST" | "DESC NULLS LAST";
+export type OrderByDirection = "ASC" | "DESC" | "ASC NULLS FIRST" | "ASC NULLS LAST" | "DESC NULLS FIRST" | "DESC NULLS LAST";
 /**
  * A keyed `orderBy` entry, used alone or in an array, like `em.find`'s `orderBy: [{ firstName: "ASC" }]`.
  *
@@ -142,7 +142,7 @@ type OrderByDirection = "ASC" | "DESC" | "ASC NULLS FIRST" | "ASC NULLS LAST" |
  * An `undefined` direction prunes the entry, like any other condition. For expressions that are not
  * in `select`, mix in `expr.asc()`/`expr.desc()` or `{ sort, order }` entries in the array form.
  */
-type OrderByKeys<S> = S extends readonly NamedSelectExpression[] ? { readonly [K in SelectKey<S[number]>]?: OrderByDirection | undefined; } : S extends {
+export type OrderByKeys<S> = S extends readonly NamedSelectExpression[] ? { readonly [K in SelectKey<S[number]>]?: OrderByDirection | undefined; } : S extends {
   readonly [tableMgmt]: {
     readonly __entity: infer T;
   };
@@ -154,11 +154,11 @@ type CheckedExpressionOrderBy<S> = ExpressionOrderBy & (string extends OrderByKe
   readonly [tableMgmt]: unknown;
 }] ? unknown : { readonly [K in Exclude<OrderByKey<S>, keyof ExpressionOrderBy>]?: never; });
 /** The select shapes: a source, scalar expression, named column array, or POJO naming result columns. */
-type QuerySelect = SelectableQuerySource | ExprLike<unknown> | readonly NamedSelectExpression[] | Record<string, SelectExpression>;
+export type QuerySelect = SelectableQuerySource | ExprLike<unknown> | readonly NamedSelectExpression[] | Record<string, SelectExpression>;
 /** A named projection value may be an existing expression or an inline expression literal. */
-type SelectExpression = ExprLike<unknown> | ExprInput;
+export type SelectExpression = ExprLike<unknown> | ExprInput;
 /** A physical or subquery column that retains the field name used for array-select result rows. */
-type NamedSelectExpression = ExprLike<unknown> & {
+export type NamedSelectExpression = ExprLike<unknown> & {
   readonly [selectKeyBrand]: string;
 };
 /** Extracts the table property name carried by a column expression for array selects. */
@@ -174,7 +174,7 @@ type CheckSelect<S> = S extends QuerySource | ExprLike<unknown> | readonly Named
  * `S` and `J` are generic so callers keep the literal shape of `select` and `join`; the defaults let
  * a standalone object use `satisfies Query` (or `satisfies Clauses` for a source-less fragment).
  */
-interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoinInput = QueryJoinInput> {
+export interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoinInput = QueryJoinInput> {
   /**
    * CTEs to include in a `WITH` clause, declared as `query(...)` values; either a single value or an array.
    *
@@ -210,7 +210,7 @@ interface Clauses<S extends QuerySelect = QuerySelect, J extends QueryJoinInput
   softDeletes?: "include" | "exclude";
 }
 /** A whole query: `Clauses` plus its source. `query(q)` turns it into a value; `em.query(q)` runs it. */
-interface Query<S extends QuerySelect = QuerySelect, J extends QueryJoinInput = QueryJoinInput> extends Clauses<S, J>, Partial<Record<SetOperation | MutationKey | "ctes", never>> {
+export interface Query<S extends QuerySelect = QuerySelect, J extends QueryJoinInput = QueryJoinInput> extends Clauses<S, J>, Partial<Record<SetOperation | MutationKey | "ctes", never>> {
   from: QuerySource;
 }
 /**
@@ -218,7 +218,7 @@ interface Query<S extends QuerySelect = QuerySelect, J extends QueryJoinInput =
  *
  * I.e. `union` removes duplicate projected Author names; `unionAll` keeps every copy.
  */
-type SetOperation = "union" | "unionAll" | "intersect" | "intersectAll" | "except" | "exceptAll";
+export type SetOperation = "union" | "unionAll" | "intersect" | "intersectAll" | "except" | "exceptAll";
 /** Mutation clauses are forbidden even on nonliteral read inputs. */
 type MutationKey = "insert" | "update" | "delete" | "values" | "set" | "returning" | "allowAll";
 /**
@@ -229,7 +229,7 @@ type MutationKey = "insert" | "update" | "delete" | "values" | "set" | "returnin
  * I.e. `{ from: a, select: { id: a.id } }` and its `query(...)` value can contribute Author IDs to a
  * union. `{ from: a, select: a.id }` cannot: even one-column set operands must give that column a name.
  */
-type SetOperand = Query<Record<string, SelectExpression> | QueryTable<unknown, string>> | QueryTable<unknown, string> | SetQuery<readonly SetOperand[]>;
+export type SetOperand = Query<Record<string, SelectExpression> | QueryTable<unknown, string>> | QueryTable<unknown, string> | SetQuery<readonly SetOperand[]>;
 /**
  * SQL-shaped compound input; use `satisfies SetQuery` to retain the operands' literal row types.
  *
@@ -248,7 +248,7 @@ type SetOperand = Query<Record<string, SelectExpression> | QueryTable<unknown, s
  * sized arrays; `CheckSetQuery` validates their row types, and runtime validation checks their length.
  * This input shape checks direction values; `CheckSetQuery` checks the inferred output keys in orderBy.
  */
-type SetQuery<Operands extends readonly SetOperand[] = readonly [SetOperand, SetOperand, ...SetOperand[]]> = { [K in SetOperation]: { readonly [P in K]: Operands; } & { readonly [P in Exclude<SetOperation, K>]?: never; }; }[SetOperation] & {
+export type SetQuery<Operands extends readonly SetOperand[] = readonly [SetOperand, SetOperand, ...SetOperand[]]> = { [K in SetOperation]: { readonly [P in K]: Operands; } & { readonly [P in Exclude<SetOperation, K>]?: never; }; }[SetOperation] & {
   /** CTEs for the combined query, declared once and in scope for every operand; see `Clauses.with`. */
   readonly with?: WithInput;
   readonly orderBy?: Readonly<Record<string, OrderByDirection | undefined>> | readonly (Readonly<Record<string, OrderByDirection | undefined>> | undefined)[];
@@ -278,7 +278,7 @@ type FirstOperand<Q> = OperandsOf<Q>[0];
  * `{ title: string | undefined }`, even though Book.title is required. A reusable `query(...)` value already
  * stores that row type in its brand; a nested compound combines its own operands recursively.
  */
-type ReadQueryRow<Q> = SetOperand extends Q ? unknown : Q extends {
+export type ReadQueryRow<Q> = SetOperand extends Q ? unknown : Q extends {
   readonly [subqueryBrand]: {
     readonly __row: infer R;
   };
@@ -295,7 +295,7 @@ type ReadQueryRow<Q> = SetOperand extends Q ? unknown : Q extends {
  * The outer conditional distributes over a TypeScript union of alternative queries. I.e. a runtime
  * choice between an Author-name UNION and a Book-order EXCEPT must retain `{ name: string } | { order: number }`.
  */
-type SetQueryRow<Q> = Q extends unknown ? { -readonly [K in keyof ReadQueryRow<FirstOperand<Q>>]: ColumnValue<Q extends {
+export type SetQueryRow<Q> = Q extends unknown ? { -readonly [K in keyof ReadQueryRow<FirstOperand<Q>>]: ColumnValue<Q extends {
   union: readonly SetOperand[];
 } | {
   unionAll: readonly SetOperand[];
@@ -314,7 +314,7 @@ type ColumnValue<R, K extends PropertyKey> = R extends unknown ? (K extends keyo
  * This is only a TypeScript check: Author.age and Author.age.sum() both pass as numbers, but runtime
  * output-type checks must still reject their different int4/int8 representations.
  */
-type CompatibleValue<L, R> = [NonNullable<L>] extends [NonNullable<R>] ? true : [NonNullable<R>] extends [NonNullable<L>] ? true : false;
+export type CompatibleValue<L, R> = [NonNullable<L>] extends [NonNullable<R>] ? true : [NonNullable<R>] extends [NonNullable<L>] ? true : false;
 /**
  * Requires exactly the same output keys and compatible TypeScript values for every column.
  *
@@ -357,7 +357,7 @@ type CheckSetOrder<O, Keys> = O extends readonly unknown[] ? { readonly [I in ke
  * The result is intersected with the inferred input Q. Unknown constraints leave its literal types
  * intact; error messages make the offending operands or ordering keys incompatible with that input.
  */
-type CheckSetQuery<Q extends SetQuery<readonly SetOperand[]>> = Q extends unknown ? SetOperand extends FirstOperand<Q> ? "set operands were typed too generically; use `satisfies SetQuery` instead" : { readonly [K in keyof Q]: K extends SetOperation ? Q[K] extends readonly SetOperand[] ? number extends Q[K]["length"] ? CheckOperands<Q[K]> : Q[K] extends readonly [SetOperand, SetOperand, ...SetOperand[]] ? CheckOperands<Q[K]> : "set operations require at least two operands" : never : unknown; } & CheckReadQuery<Q> & {
+export type CheckSetQuery<Q extends SetQuery<readonly SetOperand[]>> = Q extends unknown ? SetOperand extends FirstOperand<Q> ? "set operands were typed too generically; use `satisfies SetQuery` instead" : { readonly [K in keyof Q]: K extends SetOperation ? Q[K] extends readonly SetOperand[] ? number extends Q[K]["length"] ? CheckOperands<Q[K]> : Q[K] extends readonly [SetOperand, SetOperand, ...SetOperand[]] ? CheckOperands<Q[K]> : "set operations require at least two operands" : never : unknown; } & CheckReadQuery<Q> & {
   readonly orderBy?: CheckSetOrder<Q["orderBy"], keyof ReadQueryRow<FirstOperand<Q>>>;
 } : never;
 /**
@@ -365,7 +365,7 @@ type CheckSetQuery<Q extends SetQuery<readonly SetOperand[]>> = Q extends unknow
  * Intersect this with an inferred Q; a widened annotation cannot reveal keys already erased from its type.
  * I.e. an INSERT source with `select: { title: b.title }` and `ctes: [...]` must not silently discard the CTEs.
  */
-type CheckReadQuery<Q> = SetOperand extends Q ? unknown : Q extends readonly unknown[] ? { readonly [I in keyof Q]: CheckReadQuery<Q[I]>; } : Q extends {
+export type CheckReadQuery<Q> = SetOperand extends Q ? unknown : Q extends readonly unknown[] ? { readonly [I in keyof Q]: CheckReadQuery<Q[I]>; } : Q extends {
   readonly [subqueryBrand]: QueryTableBrand<infer R, string>;
 } ? { readonly [K in keyof Q]: K extends keyof R | typeof subqueryBrand ? unknown : never; } : Q extends {
   readonly [entityQueryBrand]: unknown;
@@ -374,7 +374,7 @@ type CheckReadQuery<Q> = SetOperand extends Q ? unknown : Q extends readonly unk
   readonly select: unknown;
 } ? CheckJoinInput<Q["from"], "join" extends keyof Q ? Exclude<Q[keyof Q & "join"], undefined> : []> & { readonly [K in keyof Q]: K extends "select" ? CheckSelect<Q[K]> : K extends keyof Clauses | "from" | "as" ? unknown : never; } : { readonly [K in keyof Q]: K extends SetOperation ? Q[K] extends readonly unknown[] ? CheckReadQuery<Q[K]> : unknown : K extends "with" | "orderBy" | "limit" | "offset" | "as" ? unknown : never; };
 /** The type-level name of a table or subquery, i.e. `"Author"` or `"book_stats"`. */
-type NameOf<A> = A extends {
+export type NameOf<A> = A extends {
   readonly [tableMgmt]: {
     readonly __name: infer N;
   };
@@ -412,7 +412,7 @@ type NullableSources<X, Left = LeftJoined<X>> = [Exclude<InheritedLeft<X, Left>,
  * table named `string` would nullify every column in the query. That is why anonymous subqueries
  * share the literal sentinel `"?"` instead.
  */
-type MaybeNull<R, Src extends string, J extends QueryJoinList> = string extends Src ? [NullableSources<J[number]>] extends [never] ? R : R | null : [Extract<Src, NullableSources<J[number]>>] extends [never] ? R : R | null;
+export type MaybeNull<R, Src extends string, J extends QueryJoinList> = string extends Src ? [NullableSources<J[number]>] extends [never] ? R : R | null : [Extract<Src, NullableSources<J[number]>>] extends [never] ? R : R | null;
 /**
  * The result row for a query with select `S` and joins `J`.
  *
@@ -422,7 +422,7 @@ type MaybeNull<R, Src extends string, J extends QueryJoinList> = string extends
  * - column array mode uses each column's field name as the result key
  * - POJO mode is a mapped type over the select keys, with left-join nullability applied
  */
-type QueryRow<S, J extends QueryJoinList = []> = S extends {
+export type QueryRow<S, J extends QueryJoinList = []> = S extends {
   readonly [tableMgmt]: {
     readonly __entity: infer T;
   };
@@ -448,7 +448,7 @@ type QueryResultValue<V> = Exclude<V, null> | (null extends V ? undefined : neve
  * while predicates and reusable queries use Sql, avoiding this reverse conversion without making the
  * common expression declaration verbose.
  */
-type SqlExpressionValue<V> = Exclude<V, undefined> | (undefined extends V ? null : never);
+export type SqlExpressionValue<V> = Exclude<V, undefined> | (undefined extends V ? null : never);
 /**
  * A table-shaped query: one `Expr` per select key, each tagged with the table's name as its `Src`,
  * plus a brand carrying the row type. This is the direct analog of `Table<T>`: `Table<T>` maps physical
@@ -456,21 +456,21 @@ type SqlExpressionValue<V> = Exclude<V, undefined> | (undefined extends V ? null
  *
  * It is a table, not only a subquery: the same value can be the `from`, be joined, or be a `with` entry.
  */
-type QueryTable<R, Name extends string> = {
+export type QueryTable<R, Name extends string> = {
   readonly [subqueryBrand]: QueryTableBrand<R, Name>;
 } & { readonly [K in keyof R]: Expr<SqlExpressionValue<R[K]>, Name> & {
   readonly [selectKeyBrand]: Extract<K, string>;
 }; };
 /** @deprecated Renamed to `QueryTable`; the value is a table shape, usable as a `with` entry too. */
-type Subquery<R, Name extends string> = QueryTable<R, Name>;
+export type Subquery<R, Name extends string> = QueryTable<R, Name>;
 /** An entity-mode query (`select: a`): runnable, but it has no columns to reference. */
-type EntityQuery<T extends Entity> = {
+export type EntityQuery<T extends Entity> = {
   readonly [entityQueryBrand]: {
     readonly __row: T;
   };
 } & Partial<Record<MutationKey | "with" | "ctes", never>>;
 /** A scalar/list query that remains distinguishable from ordinary expressions for EXISTS. */
-type ScalarQuery<R> = Expr<SqlExpressionValue<R> | null, never> & {
+export type ScalarQuery<R> = Expr<SqlExpressionValue<R> | null, never> & {
   readonly [scalarQueryBrand]: true;
 };
 /**
@@ -497,11 +497,11 @@ type ScalarQuery<R> = Expr<SqlExpressionValue<R> | null, never> & {
  * `S` also defaults to `never`, so a *missing* `select` is reported as "Property 'select' is missing"
  * against `Query<never, []>` instead of tripping this guard.
  */
-type NotWidened<S> = QuerySelect extends S ? {
+export type NotWidened<S> = QuerySelect extends S ? {
   select: "select was typed too generically; use `satisfies Query` instead of `: Query`";
 } : unknown;
 /** What `query()` returns, by select shape: an entity list, a scalar/list subquery, or a derived table. */
-type QueryValue<S, J extends QueryJoinList, Name extends string> = S extends {
+export type QueryValue<S, J extends QueryJoinList, Name extends string> = S extends {
   readonly [tableMgmt]: {
     readonly __entity: infer T extends Entity;
   };
@@ -528,7 +528,7 @@ type InScope<F, J extends QueryJoinList> = NameOf<F> | JoinedName<J[number]>;
  * `S` to `never` when `select` is missing, and a distributive conditional over `never` would swallow the
  * whole parameter type.
  */
-type CheckScope<S, F, J extends QueryJoinInput> = [S] extends [never] ? unknown : [S] extends [QuerySource] ? NameOf<S> extends NameOf<F> ? unknown : {
+export type CheckScope<S, F, J extends QueryJoinInput> = [S] extends [never] ? unknown : [S] extends [QuerySource] ? NameOf<S> extends NameOf<F> ? unknown : {
   select: `'${NameOf<S> & string}' is a joined source, not the from; select its columns individually`;
 } : [S] extends [readonly NamedSelectExpression[]] ? {
   select: { [K in keyof S]: CheckExpressionScope<S[K], InScope<F, ResolvedJoins<F, J>>>; };
@@ -538,7 +538,7 @@ type CheckScope<S, F, J extends QueryJoinInput> = [S] extends [never] ? unknown
 /** Includes columns nested in inline CASE values and fallbacks in the existing scope check. */
 type CheckExpressionScope<V, Scope> = string extends ExpressionSources<V> ? unknown : [Exclude<ExpressionSources<V>, Scope>] extends [never] ? unknown : `table '${Exclude<ExpressionSources<V>, Scope> & string}' is not in from/join`;
 /** The one argument type `query()` and `em.query()` share: a `Query` POJO plus its source, name, and checks. */
-type QueryArg<F extends QuerySource, S extends QuerySelect, J extends QueryJoinInput, Name extends string> = Query<S, J> & {
+export type QueryArg<F extends QuerySource, S extends QuerySelect, J extends QueryJoinInput, Name extends string> = Query<S, J> & {
   from: F;
   as?: Name;
 } & CheckScope<S, F, J> & NoInfer<CheckJoinInput<F, J>> & NotWidened<S> & {
@@ -562,10 +562,10 @@ type QueryArg<F extends QuerySource, S extends QuerySelect, J extends QueryJoinI
  * completions and cost 15-28% check time. The separate compound root has one additional signature;
  * `NotWidened` still rejects a SELECT widened by a `: Query` annotation.
  */
-declare function query<const Q extends SetQuery<readonly SetOperand[]>, Name extends string = "?">(q: Q & CheckSetQuery<Q> & {
+export declare function query<const Q extends SetQuery<readonly SetOperand[]>, Name extends string = "?">(q: Q & CheckSetQuery<Q> & {
   as?: Name;
 }): QueryTable<SetQueryRow<Q>, Name>;
-declare function query<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoinInput = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, ResolvedJoins<F, J>, Name>;
+export declare function query<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoinInput = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, ResolvedJoins<F, J>, Name>;
 /**
  * Builds a query value only when its user-supplied `where` or join-tree filters survive pruning.
  *
@@ -575,7 +575,7 @@ declare function query<F extends QuerySource, const S extends QuerySelect = neve
  * I.e. `queryMaybe({ from: b, where: b.authorId.eq(enabled ? a.id : undefined), select: b.id })`
  * returns `undefined` when `enabled` is false, so an enclosing `notExists` also prunes.
  */
-declare function queryMaybe<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoinInput = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, ResolvedJoins<F, J>, Name> | undefined;
+export declare function queryMaybe<F extends QuerySource, const S extends QuerySelect = never, J extends QueryJoinInput = [], Name extends string = "?">(q: QueryArg<F, S, J, Name>): QueryValue<S, ResolvedJoins<F, J>, Name> | undefined;
 /**
  * Declares a `WITH RECURSIVE` CTE from its two terms, and returns the CTE as a readable value.
  *
@@ -600,7 +600,7 @@ declare function queryMaybe<F extends QuerySource, const S extends QuerySelect =
  *
  * Unlike `query()`, the name is required, because the step term must name it.
  */
-declare function recursiveQuery<Name extends string, F extends QuerySource, const S extends QuerySelect, J extends QueryJoinInput>(name: Name, base: QueryArg<F, S, J, Name>, step: (self: QueryTable<QueryRow<S, ResolvedJoins<F, J>>, Name>) => SetOperand, opts?: RecursiveOptions): QueryTable<QueryRow<S, ResolvedJoins<F, J>>, Name>;
+export declare function recursiveQuery<Name extends string, F extends QuerySource, const S extends QuerySelect, J extends QueryJoinInput>(name: Name, base: QueryArg<F, S, J, Name>, step: (self: QueryTable<QueryRow<S, ResolvedJoins<F, J>>, Name>) => SetOperand, opts?: RecursiveOptions): QueryTable<QueryRow<S, ResolvedJoins<F, J>>, Name>;
 /**
  * Builds a SQL expression from a tagged template.
  *
@@ -619,8 +619,8 @@ declare function recursiveQuery<Name extends string, F extends QuerySource, cons
  * sql.condition`${a.column("ts_search")} @@ plainto_tsquery(${term})`
  * ```
  */
-declare function sql<R = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Expr<R, never>;
-declare namespace sql {
+export declare function sql<R = unknown>(strings: TemplateStringsArray, ...values: unknown[]): Expr<R, never>;
+export declare namespace sql {
   var number: (strings: TemplateStringsArray, ...values: unknown[]) => Expr<number, never>;
   var numberOrNull: (strings: TemplateStringsArray, ...values: unknown[]) => Expr<number | null, never>;
   var numberArray: (strings: TemplateStringsArray, ...values: unknown[]) => Expr<number[], never>;
@@ -641,19 +641,19 @@ declare namespace sql {
  * `EntityManager.query` runs the plan; this module deliberately does not import `EntityManager` (see
  * `EntityHydrator`), so it parses and hands back `{ sql, bindings, decodeRows }` instead of executing.
  */
-declare function parseRootQuery(arg: unknown): Plan;
+export declare function parseRootQuery(arg: unknown): Plan;
 /**
  * Parses a read that sits inside another statement, i.e. an INSERT's SELECT source, so it resolves that
  * statement's CTEs and shares its alias space instead of generating names that could collide with them.
  */
-declare function parseNestedQuery(arg: unknown, parent: Ctx, assigner: AliasAssigner): Plan;
+export declare function parseNestedQuery(arg: unknown, parent: Ctx, assigner: AliasAssigner): Plan;
 /** Recognizes read brands, including malformed hybrids that must reach read validation rather than mutation execution. */
-declare function isReadQueryValue(arg: unknown): boolean;
+export declare function isReadQueryValue(arg: unknown): boolean;
 /**
  * Compiles scalar or nonempty named expression projections, shared by SELECT and mutation RETURNING.
  * Source-shaped values need read hydration/source rules and are deliberately excluded here.
  */
-declare function projectionToSql(select: unknown, ctx: Ctx, joins?: QueryJoinList): {
+export declare function projectionToSql(select: unknown, ctx: Ctx, joins?: QueryJoinList): {
   selects: SqlFragment[];
   decodeRows: Plan["decodeRows"];
   output: QueryOutput;
@@ -666,10 +666,10 @@ declare function projectionToSql(select: unknown, ctx: Ctx, joins?: QueryJoinLis
  * incremental-build bug: after tsdown rewrites `build/`, `tsc --build` sporadically reports thousands
  * of phantom "Module 'joist-orm' has no exported member ..." errors and caches them in `.tsbuildinfo`.
  */
-interface EntityHydrator {
+export interface EntityHydrator {
   hydrate(cstr: any, rows: readonly any[]): any[];
 }
-interface Plan {
+export interface Plan {
   sql: string;
   bindings: any[];
   /** Aliases of enclosing queries this (sub)query referenced. */
@@ -683,13 +683,13 @@ type AnyQuery = Query<any, any> & {
 };
 type AnyReadQuery = AnyQuery | SetQuery<readonly SetOperand[]>;
 /** Only POJO outputs can be set operands; ordinary scalar reads also expose an ordered output column. */
-interface QueryOutput {
+export interface QueryOutput {
   kind: "entity" | "scalar" | "pojo";
   /** Expressions retain codecs and physical nullability after LEFT joins and set operations. */
   columns: readonly (readonly [string, BaseExpr])[];
 }
 /** The runtime identity of a `query(...)` value; `Ctx.aliasFor` keys on it, like a table's `TableMgmt`. */
-declare class SubqueryHandle {
+export declare class SubqueryHandle {
   #private;
   readonly recursive: boolean;
   constructor(q: AnyReadQuery, recursive?: boolean);
@@ -746,7 +746,7 @@ declare class SubqueryColumnExpr extends BaseExpr {
  * records the hit in `outerRefs`, which is how a correlated subquery reports the outer aliases it
  * depends on (the way `ExistsCondition.outerAliases` does), so join pruning keeps them.
  */
-declare class Ctx implements ExprContext {
+export declare class Ctx implements ExprContext {
   readonly assigner: AliasAssigner;
   private parent;
   private aliases;
@@ -808,7 +808,7 @@ declare class Ctx implements ExprContext {
   conditionToSql(cond: QueryCondition): SqlFragment | undefined;
 }
 /** A parsed `with` entry: the CTE's name and its body, ready to render into the WITH clause. */
-interface ParsedCte {
+export interface ParsedCte {
   alias: string;
   plan: Plan;
   /** A recursive CTE reads itself, and makes the whole clause `WITH RECURSIVE`. */
@@ -822,7 +822,7 @@ interface ParsedCte {
  * The conditions go into the from's WHERE or the join's ON, and never keep an otherwise unreferenced
  * join alive, which is what `pruneable: true` means on em.find's side.
  */
-declare function injectedConditions(source: {
+export declare function injectedConditions(source: {
   meta: EntityMetadata | undefined;
   alias: string;
 }, softDeletes: "include" | "exclude"): ColumnCondition[];
@@ -832,7 +832,7 @@ declare function injectedConditions(source: {
  * `pruneIfUndefined` applies unchanged. Deferred SQL expression conditions are resolved
  * against the context first.
  */
-declare function conditionToSql(cond: QueryCondition | undefined, ctx: Ctx, topLevel: boolean): SqlFragment | undefined;
+export declare function conditionToSql(cond: QueryCondition | undefined, ctx: Ctx, topLevel: boolean): SqlFragment | undefined;
 /**
  * Accepts only own enumerable POJO fields, so nothing a caller supplied can be silently ignored: the
  * compilers read these POJOs back with `Object.entries`/`Object.keys`, which skip inherited,
@@ -844,7 +844,7 @@ declare function conditionToSql(cond: QueryCondition | undefined, ctx: Ctx, topL
  * keys, i.e. a condition's predicate brand and SQL resolver. Read-query clauses instead use
  * `validateQueryKeys`, which walks the prototype chain and reports mutation clauses by name.
  */
-declare function checkPojoKeys(value: object, allowed: readonly PropertyKey[], description: string): void;
+export declare function checkPojoKeys(value: object, allowed: readonly PropertyKey[], description: string): void;
 /**
  * Names and parses each `with` entry, in declaration order.
  *
@@ -854,7 +854,7 @@ declare function checkPojoKeys(value: object, allowed: readonly PropertyKey[], d
  *
  * I.e. `with: [totals, ranked]` parses `totals` first, so `ranked` can join it, but not the reverse.
  */
-declare function registerCtes(q: {
+export declare function registerCtes(q: {
   with?: WithInput;
 }, ctx: Ctx, assigner: AliasAssigner): ParsedCte[];
 /**
@@ -863,7 +863,7 @@ declare function registerCtes(q: {
  * `referenced` is the aliases the rest of the statement used. The WITH clause leads the statement, so
  * its bindings lead the statement's bindings too.
  */
-declare function prependCtes(ctes: ParsedCte[], referenced: Set<string>, sql: string, bindings: any[]): {
+export declare function prependCtes(ctes: ParsedCte[], referenced: Set<string>, sql: string, bindings: any[]): {
   sql: string;
   bindings: any[];
 };
@@ -874,14 +874,14 @@ declare function prependCtes(ctes: ParsedCte[], referenced: Set<string>, sql: st
  * was already visited, and its own reads are already in `referenced`. That makes one pass enough; first
  * to last would have to repeat until the set stopped growing. `unshift` restores WITH order.
  */
-declare function pruneCtes(ctes: ParsedCte[], referenced: Set<string>): ParsedCte[];
+export declare function pruneCtes(ctes: ParsedCte[], referenced: Set<string>): ParsedCte[];
 /**
  * Renders `WITH a AS (...), b AS (...) `, whose bindings lead the statement, as their SQL does.
  *
  * One recursive CTE makes the whole clause `WITH RECURSIVE`, PostgreSQL's rule: the keyword is on the
  * clause, not on the entry that needs it, and it does not force the other entries to be recursive.
  */
-declare function withFragment(ctes: ParsedCte[]): SqlFragment;
+export declare function withFragment(ctes: ParsedCte[]): SqlFragment;
 //#endregion
-export { CheckReadQuery, CheckScope, CheckSetQuery, Clauses, CompatibleValue, Ctx, EntityHydrator, EntityQuery, ExistsQuery, ExpressionOrderBy, MaybeNull, NameOf, NamedSelectExpression, NotWidened, OrderByDirection, OrderByKeys, ParsedCte, Plan, Query, QueryArg, QueryCondition, QueryJoin, QueryJoinInput, QueryJoinList, QueryOutput, QueryRow, QuerySelect, QuerySource, QueryTable, QueryTableBrand, QueryValue, ReadQueryRow, RecursiveOptions, ResolvedJoins, ScalarQuery, SelectExpression, SetOperand, SetOperation, SetQuery, SetQueryRow, SqlExpressionValue, Subquery, SubqueryBrand, SubqueryHandle, WithInput, WithSource, checkPojoKeys, conditionToSql, entityQueryBrand, injectedConditions, isReadQueryValue, parseNestedQuery, parseRootQuery, prependCtes, projectionToSql, pruneCtes, query, queryMaybe, recursiveQuery, registerCtes, scalarQueryBrand, sql, subqueryBrand, withFragment };
+export {};
 //# sourceMappingURL=query.d.cts.map

package/build/queries/sql/query.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.cts","names":[],"sources":["../../../src/queries/sql/query.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA2Ga;cACA;cACA;;KAGD,cAAc,8BAA8B,YAAY;YAAsB;;;;;;;;;KAS9E,iBACR,eACA;EAEM,eAAe;EAA+B;EAAY;EAAgB;;EAC1E,cAAc;EAA+B;EAAa;EAAgB;;EAC1E;;EACJ,QAAQ;EAAyB;EAAmB;EAAa;;EACjE,WAAW;EAAyB;EAAgB;EAAa;;;UAGtD,gBAAgB,GAAG;WACzB,OAAO;WACP,QAAQ;;;KAIP,cAAc,GAAG,uBAAuB,gBAAgB,GAAG;;KAG3D;YACI,YAAY;;YACZ,gBAAgB;;;KAG3B;YACW,YAAY;;YACZ,gBAAgB;;;;;;;KAOpB,YAAY,UAAU,aAAa,kBAAkB,SAAS,aAAa;KAC3E,0BAA0B;;KAG1B,iBAAiB,gBAAgB,SAAS;;;;;KAM1C,cAAc,GAAG,KAAK,UAAU,gBACxC,IACA,UAAU,eAAe,UAAU,UACjC,YAAY,GAAG,kBAAiB,cACrB,QAAQ,GAAG;;;;;;;KAUhB,aAAa;;KAGb,YAAY,uBAAuB;;UAG9B;;EAEf;;;KAIU;WACD,MAAM;WACN;WACA;;KAGC;;;;;;;;;KAgBA,YAAY,KAEtB,mBAAmB,sCACH,KAAK,UAAU,cAAc,kCAEzC;YAAsB;aAAuB,gBAAgB;;IAC3D,UAAU,qBAEI,WAAW,MAAM,MAAM,MAAM,GAAG,WAAW,gBAAgB,aACjE,0CAKR,UAAU,wCAGI,WAAW,cAAc;;KAG1C,WAAW,KAAK,0BAA0B,YAAY;;KAGtD,yBAAyB,KAAK,oCACjB,WAAW,gBAEtB;YAAwB;2BAEX,KAAK,QAAQ,WAAW,UAAU;;KAG1C,cACR,wBACA,6BACS,0BACT,eAAe;;KAGP,mBAAmB,oBAAoB;;KAGvC,wBAAwB;YAAgC;;;KAG/D,UAAU,KAAK;YAAsB,uBAAuB;IAAqB;;KAGjF,YAAY,KAAK,UAAU,cAAc,6BAA6B,gDAE3D,WAAW,IAAI,EAAE,WAAW,YAAY,WAAW,EAAE;;;;;;;;UASpD,QAAQ,UAAU,cAAc,aAAa,UAAU,iBAAiB;;;;;;;;;EASvF,OAAO;;EAEP,OAAO;;;;;;EAMP,QAAQ,2BAA2B;EACnC,mBAAmB;EACnB,SAAS;EACT,QAAQ;EACR,oBACc,yBAAyB,KAAK,YAAY,oBACpD,yBAAyB,KACzB,YAAY;EAChB;EACA;EACA;;EAEA;;;;;;;EAOA;;;UAIe,MAAM,UAAU,cAAc,aAAa,UAAU,iBAAiB,wBAC7E,QAAQ,GAAG,IAAI,QAAQ,OAAO,eAAe;EACrD,MAAM;;;;;;;KAQI;;KAGP;;;;;;;;;KAUO,aACR,MAAM,eAAe,oBAAoB,+BACzC,8BACA,kBAAkB;;;;;;;;;;;;;;;;;;;KAoBV,SAAS,0BAA0B,yBAAyB,YAAY,eAAe,oBAEhG,KAAK,2BAA2B,KAAK,IAAI,0BAAyB,KAAK,QAAQ,cAAc,kBAC9F;;WAGS,OAAO;WACP,UACL,SAAS,eAAe,2CACd,SAAS,eAAe;WAC7B;WACA;WACA;gBAIP,+GAUI;;;;;;;;KAYH,WAAW,KAAK,oBAAoB,QAAQ,QAAQ,IAAI,wBAAwB;;;;;;;KAQhF,aAAa,KAAK,WAAW;;;;;;;;KAStB,aAAa,KAAK,mBAAmB,cAI7C;YAAsB;aAA2B,aAAa;;IAC5D,IACA;EAAY,cAAc;IAExB,SACE,GACA,cAAc,QAAQ,kCAAkC,IAAI,QAAQ,QAAQ,aAAa,0BAE1F,WAAW,8BAEV,YAAY;;;;;;;;;;;KAYV,YAAY,KAAK,iCAGZ,WAAW,aAAa,aAAa,MAAM,YAEpD;EAAY,gBAAgB;;EAAmB,mBAAmB;IAC9D,aAAa,WAAW,cACxB,aAAa,aAAa,KAC9B;;;;;;;KAWH,YAAY,GAAG,UAAU,eAAe,qBAAqB,gBAAgB,IAAI,EAAE;;;;;;;;KAS5E,gBAAgB,GAAG,MAAM,YAAY,aAAa,YAAY,cAErE,YAAY,aAAa,YAAY;;;;;;;;KAWrC,cAAc,GAAG,YAAY,kBAAkB,YAEzC,kBAAkB,sBAEN,WAAW,IAAI,gBAAgB,EAAE,IAAI,YAAY,GAAG,aAAY;;;;;;;;KAalF,aAAa,OAAO,KACvB,cAAc,aAAa,QAAQ,aAAa,mBAE5C,UAAU,kBAAkB,gBAC1B,cAAc,KACd,eAAe;;;;;;;;KAUlB,cAAc,mBAAmB,4BAA4B,WAAW,IAAI,aAAa,MAAM,EAAE;;;;;;;KAQjG,cAAc,GAAG,QAAQ,2CAEd,WAAW,IAAI,cAAc,EAAE,IAAI,uBACnC,WAAW,IAAI,UAAU;;;;;;;;;;;;KAa7B,cAAc,UAAU,kBAAkB,iBAAiB,oBAEnE,mBAAmB,aAAa,+FAIlB,WAAW,IAAI,UAAU,eAC/B,EAAE,oBAAoB,8BAEL,EAAE,eACf,cAAc,EAAE,MAEhB,EAAE,qBAAqB,YAAY,eAAe,gBAChD,cAAc,EAAE,4EAKxB,eAAe;WAEN,UAAU,cAAc,oBAAoB,aAAa,aAAa;;;;;;;KAS7E,eAAe,KAAK,mBAAmB,cAE/C,2CACc,WAAW,IAAI,eAAe,EAAE,SAC5C;YAAsB,gBAAgB,sBAAsB;gBAC9C,WAAW,IAAI,gBAAgB,WAAW,qCACtD;YAAsB;gBACR,WAAW,IAAI,iBAAiB,wCAC5C;WAAqB;WAAwB;IAC3C,eAAe,gCAAgC,IAAI,QAAQ,QAAQ,4CACvD,WAAW,IAAI,qBACrB,YAAY,EAAE,MACd,gBAAgB,2DAKV,WAAW,IAAI,UAAU,eAC/B,EAAE,gCACA,eAAe,EAAE,gBAEnB;;KAUN,OAAO,KAAK;YAAsB;aAAuB,cAAc;;IAC/E,IACA;YAAsB;aAA2B,cAAc;;IAC7D;;KAID,WAAW,KAAK,UAAU,eAAe,KAAK,OAAO;;KAGrD,cAAc,GAAG,QAAQ;YAAsB,4BAA4B;WAAc,aAAa;KAGtG,QAAQ,KAAK,iCAEZ,OAAO;;;;;;KAQR,gBAAgB,GAAG,OAAO,WAAW,OAOvC,QAAQ,cAAc,GAAG,OAAO,yBAAyB,OAAO,gBAAgB,GAAG,OAAO,cAAc,GAAG;;;;;;;;;;;;;;;;;KAkBlG,UAAU,GAAG,oBAAoB,UAAU,gCAAgC,OAClF,gBAAgB,8BACf,IACA,YACD,QAAQ,KAAK,gBAAgB,+BAC5B,IACA;;;;;;;;;;KAWM,SAAS,GAAG,UAAU,sBAAsB;YAC5C;aAAuB,gBAAgB;;IAE/C,IACA;YAAsB;aAA2B,aAAa;;IAC5D,IACA,UAAU,oBACR,iBAAiB,gBAAgB,GAAG,MAEpC,mBAAmB,uCAIJ,KAAK,aAAa,UAAU,KAAK,iBAAiB,gBAAgB,GAAG,sBAIrE,WAAW,IAAI,EAAE,WAAW,mBACnC,iBAAiB,gBAAgB,EAAE,WAAW,YAAY,cAAc,EAAE,MAAM,EAAE,IAAI;;;;;;;;;KAYjG,iBAAiB,KAAK,QAAQ,yBAAyB;;;;;;;;;KAUhD,mBAAmB,KAAK,QAAQ,mCAAmC;;;;;;;;KAanE,WAAW,GAAG;YACd,gBAAgB,gBAAgB,GAAG;gBAInC,WAAW,IAAI,KAAK,mBAAmB,EAAE,KAAK;YAAoB,iBAAiB,QAAQ;;;KAI3F,SAAS,GAAG,uBAAuB,WAAW,GAAG;;KAGjD,YAAY,UAAU;YAAsB;aAA8B,OAAO;;IAAQ,QACnG,OAAO;;KAIG,YAAY,KAAK,KAAK,mBAAmB;YAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;KA0BzE,WAAW,KAAK,oBAAoB;EAC1C;;;KAIM,WAAW,GAAG,UAAU,eAAe,uBAAuB;YAC9D;aAAuB,gBAAgB,UAAU;;IAEzD,YAAY,KACZ,UAAU,oBACR,YAAY,SAAS,GAAG,MACxB,WAAW,SAAS,GAAG,IAAI;;KAG5B,WAAW,KAAK;WAAqB,aAAa;IACnD,OAAO,KACP;WAAqB,YAAY;IAC/B,OAAO;KAER,QAAQ,GAAG,UAAU,iBAAiB,OAAO,KAAK,WAAW;;;;;;;;;;;;;;;;KAiBtD,WAAW,GAAG,GAAG,UAAU,mBAAmB,gCAMrD,YAAY,eACX,OAAO,WAAW,OAAO;EAErB,YAAY,OAAO;KACtB,qBAAqB;EAGlB,WAAW,WAAW,IAAI,qBAAqB,EAAE,IAAI,QAAQ,GAAG,cAAc,GAAG;KAElF,YAAY,eAAe;EAGxB,WACG,WAAW,IAAI,qBAAqB,EAAE,IAAI,QAAQ,GAAG,cAAc,GAAG;;;KAMhF,qBAAqB,GAAG,wBACZ,kBAAkB,gBAE5B,QAAQ,kBAAkB,IAAI,8CAEnB,QAAQ,kBAAkB,IAAI;;KAGpC,SACV,UAAU,aACV,UAAU,aACV,UAAU,gBACV,uBACE,MAAM,GAAG;EACX,MAAM;EACN,KAAK;IACH,WAAW,GAAG,GAAG,KACnB,QAAQ,eAAe,GAAG,MAC1B,WAAW;EAAO,QAAQ,YAAY,QAAQ;;;;;;;;;;;;;;;;;;;;iBAoBhC,YAAY,UAAU,kBAAkB,eAAe,2BACrE,GAAG,IAAI,cAAc;EAAO,KAAK;IAChC,WAAW,YAAY,IAAI;iBACd,MACd,UAAU,mBACJ,UAAU,qBAChB,UAAU,qBACV,2BACA,GAAG,SAAS,GAAG,GAAG,GAAG,QAAQ,WAAW,GAAG,cAAc,GAAG,IAAI;;;;;;;;;;iBAclD,WACd,UAAU,mBACJ,UAAU,qBAChB,UAAU,qBACV,2BACA,GAAG,SAAS,GAAG,GAAG,GAAG,QAAQ,WAAW,GAAG,cAAc,GAAG,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;iBAoClD,eACd,qBACA,UAAU,mBACJ,UAAU,aAChB,UAAU,gBAEV,MAAM,MACN,MAAM,SAAS,GAAG,GAAG,GAAG,OACxB,OAAO,MAAM,WAAW,SAAS,GAAG,cAAc,GAAG,KAAK,UAAU,YACpE,OAAM,mBACL,WAAW,SAAS,GAAG,cAAc,GAAG,KAAK;;;;;;;;;;;;;;;;;;;iBAgChC,IAAI,aAAa,SAAS,yBAAyB,oBAAoB,KAAK;kBAA5E;MA8tDc,SAAA,SAAA,yBAAoB,sBAAsB;MAA1C,eAAA,SAAA,yBAAoB,sBAAsB;MAA1C,cAAA,SAAA,yBAAoB,sBAAsB;MAA1C,oBAAA,SAAA,yBAAoB,sBAAsB;MAA1C,SAAA,SAAA,yBAAoB,sBAAsB;MAA1C,eAAA,SAAA,yBAAoB,sBAAsB;MAA1C,cAAA,SAAA,yBAAoB,sBAAsB;MAA1C,oBAAA,SAAA,yBAAoB,sBAAsB;MAA1C,UAAA,SAAA,yBAAoB,sBAAsB;MAA1C,gBAAA,SAAA,yBAAoB,sBAAsB;MAA1C,eAAA,SAAA,yBAAoB,sBAAsB;MAA1C,qBAAA,SAAA,yBAAoB,sBAAsB;MArrD5B,YAAA,SAAA,yBAAoB,sBAAyB;;;;;;;;iBAUzE,eAAe,eAAe;;;;;iBAS9B,iBAAiB,cAAc,QAAQ,KAAK,UAAU,gBAAgB;;iBAMtE,iBAAiB;;;;;iBAQjB,gBACd,iBACA,KAAK,KACL,QAAQ;EACL,SAAS;EAAe,YAAY;EAAoB,QAAQ;;;;;;;;;;UAmCpD;EACf,QAAQ,WAAW;;UAGJ;EACf;EACA;;EAEA;;EAEA,QAAQ;EACR,WAAW,IAAI,gBAAgB;;KAO5B,WAAW;EAAoB;;KAC/B,eAAe,WAAW,kBAAkB;;UAGhC;EACf;;EAEA,qCAAqC;;;cAI1B;;WAMA;EAFX,YACE,GAAG,cACM;MAKP,KAAK;;;;;;;;;EAYT,QAAQ,GAAG;MAOP;;EAKJ;;EAOA,WAAW,cAAc;;;;;;;;;;;;;;EAoBzB,UAAU;EAIV,OAAO,cAAc;EAIrB;;;cAMI,2BAA2B;UAErB;UACA;UACA;EAHV,YACU,QAAQ,gBACR,aACA,OAAO;OAKZ;EAIL,MAAM,KAAK,cAAc;EAMzB,OAAO;EAIP,OAAO;MAIH,cAAc;MAId;MAIA;;;;;;;;;cAicO,eAAe;WAqBf,UAAU;UACX;UArBF;;;;;;UAMA;;;;;;UAMA;;UAEA;;UAEA;WACC,WAAS;EAElB,YACW,UAAU,eACX,QAAQ;;;;;EAOlB,SAAS,gBAAgB;;EAUzB,WAAW,gBAAgB;;EAK3B,WAAW;;;;;;;;EAcX,YAAY;;;;;;;MAUR,iBAAiB;EAIrB,iBAAiB,QAAQ;;EAKzB,aAAa;;;;;;;;;EAYb,OAAO;EASP,SAAS;EAWT,eAAe,MAAM,iBAAiB;;;UA2BvB;EACf;EACA,MAAM;;EAEN;;;;;;;;;;iBAoNc,mBACd;EAAU,MAAM;EAA4B;GAC5C,qCACC;;;;;;;iBAiSa,eAAe,MAAM,4BAA4B,KAAK,KAAK,oBAAoB;;;;;;;;;;;;iBAuI/E,cAAc,eAAe,kBAAkB,eAAe;;;;;;;;;;iBA0J9D,aAAa;EAAK,OAAO;GAAa,KAAK,KAAK,UAAU,gBAAgB;;;;;;;iBAmC1E,YACd,MAAM,aACN,YAAY,aACZ,aACA;EACG;EAAa;;;;;;;;;iBAcF,UAAU,MAAM,aAAa,YAAY,cAAc;;;;;;;iBAiBvD,aAAa,MAAM,cAAc"}
+{"version":3,"file":"query.d.cts","names":[],"sources":["../../../src/queries/sql/query.ts"],"mappings":"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"}