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

package/build/queries/find/EntityFilter.d.mts

@@ -6,7 +6,7 @@ import { FindFilterOptions, IdOf } from "../../EntityManager.mjs";
 import { Entity } from "../../Entity.mjs";
 //#region src/queries/find/EntityFilter.d.ts
 /** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
-type FilterAndSettings<T extends Entity> = {
+export type FilterAndSettings<T extends Entity> = {
   where: FindFilter<T>;
   conditions?: ExpressionFilter;
   orderBy?: OrderOf<T> | OrderOf<T>[];
@@ -16,7 +16,7 @@ type FilterAndSettings<T extends Entity> = {
   allowMultipleLeftJoins?: boolean;
   optimizeJoinsToExists?: boolean;
 };
-type OrderBy = "ASC" | "DESC";
+export type OrderBy = "ASC" | "DESC";
 /**
  * A filter for an entity of type `T` for `em.find` inline conditions.
  *
@@ -28,16 +28,16 @@ type OrderBy = "ASC" | "DESC";
  * @typeparam F The filter type for the entity, i.e. `AuthorFilter`
  * @typeparam N Either `null | undefined` if the entity can be null, or `never` if it cannot.
  */
-type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = T | readonly T[] | I | readonly I[] | Scope<T> | EntityFilterObject<T, I, F, N> | undefined | N | {
+export type EntityFilter<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = T | readonly T[] | I | readonly I[] | Scope<T> | EntityFilterObject<T, I, F, N> | undefined | N | {
   ne: T | I | N | undefined;
 } | boolean | Alias<T>;
 /** A nested object filter, including logical composition at the current entity alias. */
-type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {
+export type EntityFilterObject<T extends Entity, I = IdOf<T>, F = FilterOf<T>, N = never> = {
   as?: Alias<T>;
   and?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
   or?: EntityFilter<T, I, F, N> | readonly EntityFilter<T, I, F, N>[];
 } & F;
-type BooleanFilter<N> = true | false | N;
+export type BooleanFilter<N> = true | false | N;
 /**
  * The root `em.find` `where` shape: an `EntityFilterObject` with `I`/`F`/`N` defaulted.
  *
@@ -47,10 +47,10 @@ type BooleanFilter<N> = true | false | N;
  * nullability (`N`) flow through `and`/`or` recursion — which a `FilterOf<T>`-hardcoded root can't
  * supply, so the shape lives on `EntityFilterObject` and this just specializes it.
  */
-type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;
+export type FilterWithAlias<T extends Entity> = EntityFilterObject<T>;
 /** Allows `em.find` to accept either a `{ ... }` EntityFilter or a Scope like `Adult.parent` */
-type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;
-type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends {
+export type FindFilter<T extends Entity> = FilterWithAlias<T> | Scope<T>;
+export type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf<T> as FieldsOf<T>[K] extends {
   unique: true;
 } ? K : never]?: FilterOf<T>[K]; };
 /**
@@ -59,7 +59,7 @@ type UniqueFilter<T extends Entity> = { [K in keyof FieldsOf<T> & keyof FilterOf
  * We always allow `undefined` to support condition pruning, but only conditionally
  * allow `null` if the column is actually nullable.
  */
-type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
+export type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
   eq: V | N | undefined;
 } | {
   ne: V | N | undefined;
@@ -114,14 +114,13 @@ type ValueFilter<V, N> = V | readonly V[] | N | undefined | {
  *
  * This is the user-facing DSL that internally will be converted to `ParsedExpressionFilter.
  */
-type ExpressionFilter = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;
+export type ExpressionFilter = AndCondition<ExpressionCondition> | OrCondition<ExpressionCondition>;
 /** A domain-alias predicate or nested group for em.find and scopes, not SQL table expressions. */
-type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;
+export type ExpressionCondition = ExpressionFilter | DomainPredicate | UnbrandedPredicate;
 /** Merges root-scope find settings with caller options, letting caller options win. */
-declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>, options: FindFilterOptions<T>): {
+export declare function mergeFindOptions<T extends Entity>(where: FindFilter<T>, options: FindFilterOptions<T>): {
   where: FindFilter<T>;
   options: FindFilterOptions<T>;
 };
 //#endregion
-export { BooleanFilter, EntityFilter, EntityFilterObject, ExpressionCondition, ExpressionFilter, FilterAndSettings, FilterWithAlias, FindFilter, OrderBy, UniqueFilter, ValueFilter, mergeFindOptions };
 //# sourceMappingURL=EntityFilter.d.mts.map

package/build/queries/find/EntityFilter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityFilter.d.mts","names":[],"sources":["../../../src/queries/find/EntityFilter.ts"],"mappings":";;;;;;;;KAQY,kBAAkB,UAAU;EAEtC,OAAO,WAAW;EAClB,aAAa;EACb,UAAU,QAAQ,KAAK,QAAQ;EAC/B;EACA;EACA;EACA;EACA;;KAGU;;;;;;;;;;;;KAaA,aAAa,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,aACrE,aACS,MACT,aACS,MACT,MAAM,KAEN,mBAAmB,GAAG,GAAG,GAAG,iBAI5B;EACE,IAAI,IAAI,IAAI;cAGd,MAAM;;KAGE,mBAAmB,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI;EAC7E,KAAK,MAAM;EACX,MAAM,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;EAChE,KAAK,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;IAC7D;KAEQ,cAAc,oBAAoB;;;;;;;;;;KAWlC,gBAAgB,UAAU,UAAU,mBAAmB;;KAGvD,WAAW,UAAU,UAAU,gBAAgB,KAAK,MAAM;KAE1D,aAAa,UAAU,aAChC,WAAW,SAAS,WAAW,SAAS,MAAM,SAAS,GAAG;EAAa;IAAiB,aAAa,SAAS,GAAG;;;;;;;KASxG,YAAY,GAAG,KACvB,aACS,MACT;EAGE,IAAI,IAAI;;EACR,IAAI,IAAI;;EACR,cAAc,IAAI;;EAClB,eAAe,IAAI;;EACnB,IAAI;;EACJ,KAAK;;EACL,IAAI;;EACJ,KAAK;;EACL,MAAM;;EACN,OAAO;;EACP,OAAO;;EACP,QAAQ;;EACR,QAAQ;;EACR,SAAS;;EACT,SAAS;;EACT,UAAU;;EACV,QAAQ;;EAER,UAAU;;EACV,UAAU;;EACV,aAAa;;EAEb;;EACA;;EAEA,KAAK;EAAe,KAAK;;EACzB,UAAU,GAAG;;;;;;;KAOP,mBAAmB,aAAa,uBAAuB,YAAY;;KAGnE,sBAAsB,mBAAmB,kBAAkB;;iBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}
+{"version":3,"file":"EntityFilter.d.mts","names":[],"sources":["../../../src/queries/find/EntityFilter.ts"],"mappings":";;;;;;;;YAQY,kBAAkB,UAAU;EAEtC,OAAO,WAAW;EAClB,aAAa;EACb,UAAU,QAAQ,KAAK,QAAQ;EAC/B;EACA;EACA;EACA;EACA;;YAGU;;;;;;;;;;;;YAaA,aAAa,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI,aACrE,aACS,MACT,aACS,MACT,MAAM,KAEN,mBAAmB,GAAG,GAAG,GAAG,iBAI5B;EACE,IAAI,IAAI,IAAI;cAGd,MAAM;;YAGE,mBAAmB,UAAU,QAAQ,IAAI,KAAK,IAAI,IAAI,SAAS,IAAI;EAC7E,KAAK,MAAM;EACX,MAAM,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;EAChE,KAAK,aAAa,GAAG,GAAG,GAAG,cAAc,aAAa,GAAG,GAAG,GAAG;IAC7D;YAEQ,cAAc,oBAAoB;;;;;;;;;;YAWlC,gBAAgB,UAAU,UAAU,mBAAmB;;YAGvD,WAAW,UAAU,UAAU,gBAAgB,KAAK,MAAM;YAE1D,aAAa,UAAU,aAChC,WAAW,SAAS,WAAW,SAAS,MAAM,SAAS,GAAG;EAAa;IAAiB,aAAa,SAAS,GAAG;;;;;;;YASxG,YAAY,GAAG,KACvB,aACS,MACT;EAGE,IAAI,IAAI;;EACR,IAAI,IAAI;;EACR,cAAc,IAAI;;EAClB,eAAe,IAAI;;EACnB,IAAI;;EACJ,KAAK;;EACL,IAAI;;EACJ,KAAK;;EACL,MAAM;;EACN,OAAO;;EACP,OAAO;;EACP,QAAQ;;EACR,QAAQ;;EACR,SAAS;;EACT,SAAS;;EACT,UAAU;;EACV,QAAQ;;EAER,UAAU;;EACV,UAAU;;EACV,aAAa;;EAEb;;EACA;;EAEA,KAAK;EAAe,KAAK;;EACzB,UAAU,GAAG;;;;;;;YAOP,mBAAmB,aAAa,uBAAuB,YAAY;;YAGnE,sBAAsB,mBAAmB,kBAAkB;;wBAGvD,iBAAiB,UAAU,QACzC,OAAO,WAAW,IAClB,SAAS,kBAAkB;EACxB,OAAO,WAAW;EAAI,SAAS,kBAAkB"}

package/build/queries/find/EntityGraphQLFilter.d.cts

@@ -3,11 +3,11 @@ import { Alias } from "./Aliases.cjs";
 import { EntityFilter, ExpressionFilter } from "./EntityFilter.cjs";
 import { Entity } from "../../Entity.cjs";
 //#region src/queries/find/EntityGraphQLFilter.d.ts
-type GraphQLFilterWithAlias<T extends Entity> = {
+export type GraphQLFilterWithAlias<T extends Entity> = {
   as?: Alias<T>;
 } & GraphQLFilterOf<T>;
 /** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
-type GraphQLFilterAndSettings<T extends Entity> = {
+export type GraphQLFilterAndSettings<T extends Entity> = {
   where: GraphQLFilterWithAlias<T>;
   conditions?: ExpressionFilter;
   orderBy?: OrderOf<T>;
@@ -20,7 +20,7 @@ type GraphQLFilterAndSettings<T extends Entity> = {
 /**
  * This essentially matches the ValueFilter but with looser types to placate GraphQL.
  */
-type ValueGraphQLFilter<V> = {
+export type ValueGraphQLFilter<V> = {
   eq?: V | null;
   in?: readonly V[] | null;
   nin?: readonly V[] | null;
@@ -48,12 +48,11 @@ type ValueGraphQLFilter<V> = {
   op: Operator;
   value: V | readonly V[] | undefined | null;
 } | V | readonly V[] | null;
-type BooleanGraphQLFilter = true | false | null;
-declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "nlike", "ilike", "nilike", "regex", "iregex", "nregex", "niregex", "in", "nin", "between", "contains", "overlaps", "containedBy", "jsonPathExists", "jsonPathPredicate"];
-type Operator = (typeof operators)[number];
-declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
+export type BooleanGraphQLFilter = true | false | null;
+export declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "nlike", "ilike", "nilike", "regex", "iregex", "nregex", "niregex", "in", "nin", "between", "contains", "overlaps", "containedBy", "jsonPathExists", "jsonPathPredicate"];
+export type Operator = (typeof operators)[number];
+export declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
 /** A GraphQL version of EntityFilter. */
-type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
+export type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
 //#endregion
-export { BooleanGraphQLFilter, EntityGraphQLFilter, GraphQLFilterAndSettings, GraphQLFilterWithAlias, Operator, ValueGraphQLFilter, opToFn, operators };
 //# sourceMappingURL=EntityGraphQLFilter.d.cts.map

package/build/queries/find/EntityGraphQLFilter.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityGraphQLFilter.d.cts","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"mappings":";;;;;KAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;KAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;KAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;KAGD;cAEC;KA0BD,mBAAmB;cAElB,QAAQ,OAAO,QAAQ;;KA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}
+{"version":3,"file":"EntityGraphQLFilter.d.cts","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"mappings":";;;;;YAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;YAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;YAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;YAGD;qBAEC;YA0BD,mBAAmB;qBAElB,QAAQ,OAAO,QAAQ;;YA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}

package/build/queries/find/EntityGraphQLFilter.d.mts

@@ -3,11 +3,11 @@ import { Alias } from "./Aliases.mjs";
 import { EntityFilter, ExpressionFilter } from "./EntityFilter.mjs";
 import { Entity } from "../../Entity.mjs";
 //#region src/queries/find/EntityGraphQLFilter.d.ts
-type GraphQLFilterWithAlias<T extends Entity> = {
+export type GraphQLFilterWithAlias<T extends Entity> = {
   as?: Alias<T>;
 } & GraphQLFilterOf<T>;
 /** Combines a `where` filter with optional `orderBy`, `limit`, and `offset` settings. */
-type GraphQLFilterAndSettings<T extends Entity> = {
+export type GraphQLFilterAndSettings<T extends Entity> = {
   where: GraphQLFilterWithAlias<T>;
   conditions?: ExpressionFilter;
   orderBy?: OrderOf<T>;
@@ -20,7 +20,7 @@ type GraphQLFilterAndSettings<T extends Entity> = {
 /**
  * This essentially matches the ValueFilter but with looser types to placate GraphQL.
  */
-type ValueGraphQLFilter<V> = {
+export type ValueGraphQLFilter<V> = {
   eq?: V | null;
   in?: readonly V[] | null;
   nin?: readonly V[] | null;
@@ -48,12 +48,11 @@ type ValueGraphQLFilter<V> = {
   op: Operator;
   value: V | readonly V[] | undefined | null;
 } | V | readonly V[] | null;
-type BooleanGraphQLFilter = true | false | null;
-declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "nlike", "ilike", "nilike", "regex", "iregex", "nregex", "niregex", "in", "nin", "between", "contains", "overlaps", "containedBy", "jsonPathExists", "jsonPathPredicate"];
-type Operator = (typeof operators)[number];
-declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
+export type BooleanGraphQLFilter = true | false | null;
+export declare const operators: readonly ["eq", "gt", "gte", "ne", "lt", "lte", "like", "nlike", "ilike", "nilike", "regex", "iregex", "nregex", "niregex", "in", "nin", "between", "contains", "overlaps", "containedBy", "jsonPathExists", "jsonPathPredicate"];
+export type Operator = (typeof operators)[number];
+export declare const opToFn: Record<Exclude<Operator, "in" | "nin" | "between">, string>;
 /** A GraphQL version of EntityFilter. */
-type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
+export type EntityGraphQLFilter<T extends Entity, I, F, N> = EntityFilter<T, I, F, N> | null;
 //#endregion
-export { BooleanGraphQLFilter, EntityGraphQLFilter, GraphQLFilterAndSettings, GraphQLFilterWithAlias, Operator, ValueGraphQLFilter, opToFn, operators };
 //# sourceMappingURL=EntityGraphQLFilter.d.mts.map

package/build/queries/find/EntityGraphQLFilter.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityGraphQLFilter.d.mts","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"mappings":";;;;;KAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;KAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;KAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;KAGD;cAEC;KA0BD,mBAAmB;cAElB,QAAQ,OAAO,QAAQ;;KA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}
+{"version":3,"file":"EntityGraphQLFilter.d.mts","names":[],"sources":["../../../src/queries/find/EntityGraphQLFilter.ts"],"mappings":";;;;;YAKY,uBAAuB,UAAU;EAAY,KAAK,MAAM;IAAO,gBAAgB;;YAG/E,yBAAyB,UAAU;EAC7C,OAAO,uBAAuB;EAC9B,aAAa;EACb,UAAU,QAAQ;EAClB;EACA;EACA;EACA;EACA;;;;;YAMU,mBAAmB;EAEzB,KAAK;EACL,cAAc;EACd,eAAe;EACf,KAAK;EACL,MAAM;EACN,KAAK;EACL,KAAK;EACL,MAAM;EACN,OAAO;EACP,QAAQ;EACR,QAAQ;EACR,SAAS;EACT,QAAQ;EACR,SAAS;EACT,SAAS;EACT,UAAU;EACV,SAAS;EACT,mBAAmB;EACnB,WAAW;EACX,WAAW;EACX,cAAc;EACd;EACA;;EAEA,IAAI;EAAU,OAAO,aAAa;IACpC,aACS;YAGD;qBAEC;YA0BD,mBAAmB;qBAElB,QAAQ,OAAO,QAAQ;;YA0BxB,oBAAoB,UAAU,QAAQ,GAAG,GAAG,KAAK,aAAa,GAAG,GAAG,GAAG"}

package/build/queries/find/QueryParser.collectionJoins.d.cts

@@ -19,12 +19,11 @@ import { ParsedFindQuery } from "./QueryParser.cjs";
  *    because they can produce cross-product row explosions.
  * 5. Finally, `maybeAddIdNotNulls` and `pruneUnusedJoins` clean up the joins that remain.
  */
-declare function optimizeCollectionJoins(query: ParsedFindQuery, opts?: {
+export declare function optimizeCollectionJoins(query: ParsedFindQuery, opts?: {
   allowMultipleLeftJoins?: boolean;
   optimizeJoinsToExists?: boolean;
   pruneJoins?: boolean;
   keepAliases?: string[];
 }): void;
 //#endregion
-export { optimizeCollectionJoins };
 //# sourceMappingURL=QueryParser.collectionJoins.d.cts.map

package/build/queries/find/QueryParser.collectionJoins.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryParser.collectionJoins.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.collectionJoins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBA6CgB,wBACd,OAAO,iBACP;EACE;EACA;EACA;EACA"}
+{"version":3,"file":"QueryParser.collectionJoins.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.collectionJoins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBA6CgB,wBACd,OAAO,iBACP;EACE;EACA;EACA;EACA"}

package/build/queries/find/QueryParser.collectionJoins.d.mts

@@ -19,12 +19,11 @@ import { ParsedFindQuery } from "./QueryParser.mjs";
  *    because they can produce cross-product row explosions.
  * 5. Finally, `maybeAddIdNotNulls` and `pruneUnusedJoins` clean up the joins that remain.
  */
-declare function optimizeCollectionJoins(query: ParsedFindQuery, opts?: {
+export declare function optimizeCollectionJoins(query: ParsedFindQuery, opts?: {
   allowMultipleLeftJoins?: boolean;
   optimizeJoinsToExists?: boolean;
   pruneJoins?: boolean;
   keepAliases?: string[];
 }): void;
 //#endregion
-export { optimizeCollectionJoins };
 //# sourceMappingURL=QueryParser.collectionJoins.d.mts.map

package/build/queries/find/QueryParser.collectionJoins.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryParser.collectionJoins.d.mts","names":[],"sources":["../../../src/queries/find/QueryParser.collectionJoins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;iBA6CgB,wBACd,OAAO,iBACP;EACE;EACA;EACA;EACA"}
+{"version":3,"file":"QueryParser.collectionJoins.d.mts","names":[],"sources":["../../../src/queries/find/QueryParser.collectionJoins.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;wBA6CgB,wBACd,OAAO,iBACP;EACE;EACA;EACA;EACA"}

package/build/queries/find/QueryParser.d.cts

@@ -2,12 +2,12 @@ import { ParsedExpressionFilter } from "../parsedConditions.cjs";
 import { ExpressionFilter, OrderBy } from "./EntityFilter.cjs";
 import { EntityMetadata, Field } from "../../EntityMetadata.cjs";
 //#region src/queries/find/QueryParser.d.ts
-interface PrimaryTable {
+export interface PrimaryTable {
   join: "primary";
   alias: string;
   table: string;
 }
-interface JoinTable {
+export interface JoinTable {
   join: "inner" | "outer";
   alias: string;
   table: string;
@@ -62,7 +62,7 @@ interface JoinTable {
  * GROUP BY a.id
  * ```
  */
-interface CrossJoinTable {
+export interface CrossJoinTable {
   join: "cross";
   /** The new alias for the joined table. */
   alias: string;
@@ -80,7 +80,7 @@ interface CrossJoinTable {
  * )
  * ```
  */
-interface ParsedCteClause {
+export interface ParsedCteClause {
   /** The new alias for the CTE, i.e. `_find` in the above query. */
   alias: string;
   /** The columns, i.e. `tag, arg0, arg1` in the above query. */
@@ -103,7 +103,7 @@ interface ParsedCteClause {
 /**
  * Creates `LATERAL JOIN`s, currently used by `findCount` and JSON preloading.
  */
-interface LateralJoinTable {
+export interface LateralJoinTable {
   join: "lateral";
   alias: string;
   /** Used for join dependency tracking. */
@@ -118,26 +118,26 @@ interface LateralJoinTable {
     offset?: number;
   };
 }
-type ParsedTable = PrimaryTable | JoinTable | CrossJoinTable | LateralJoinTable;
-interface ParsedOrderBy {
+export type ParsedTable = PrimaryTable | JoinTable | CrossJoinTable | LateralJoinTable;
+export interface ParsedOrderBy {
   alias: string;
   column: string;
   order: OrderBy;
 }
-type ParsedGroupBy = {
+export type ParsedGroupBy = {
   alias: string;
   column: string;
 } | {
   expression: string;
 };
-type ParsedSelect = string | ParsedSelectWithBindings;
+export type ParsedSelect = string | ParsedSelectWithBindings;
 type ParsedSelectWithBindings = {
   sql: string;
   bindings: any[];
   aliases: string[];
 };
 /** The result of parsing an `em.find` filter. */
-interface ParsedFindQuery {
+export interface ParsedFindQuery {
   selects: ParsedSelect[];
   /** The primary table plus any joins. */
   tables: ParsedTable[];
@@ -156,7 +156,7 @@ interface ParsedFindQuery {
  * The main execution flow is:
  * parseFindQuery -> beforeFind plugins -> optimizeCollectionJoins -> pruneUnusedJoins -> execute SQL.
  */
-declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
+export declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
   conditions?: ExpressionFilter;
   orderBy?: any;
   pruneJoins?: boolean;
@@ -176,17 +176,17 @@ declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
  * to do an `OR` across two different children (which queries both children being
  * OUTER JOINs, and detecting that case seemed complicated).
  */
-declare function maybeAddIdNotNulls(query: ParsedFindQuery): void;
+export declare function maybeAddIdNotNulls(query: ParsedFindQuery): void;
 /** Returns the `a` from `"a".*`. */
-declare function parseAlias(alias: string): string;
+export declare function parseAlias(alias: string): string;
 /** Finds a filter field by fieldName or generated fieldIdName. */
-declare function findFilterField(meta: EntityMetadata, key: string): (Field & {
+export declare function findFilterField(meta: EntityMetadata, key: string): (Field & {
   aliasSuffix: string;
 }) | undefined;
 /** Adds any user-configured default order, plus an "always order by id" for determinism. */
-declare function maybeAddOrderBy(query: ParsedFindQuery, meta: EntityMetadata, alias: string): void;
-declare function addTablePerClassJoinsAndClassTag(query: ParsedFindQuery, meta: EntityMetadata, alias: string, isPrimary: boolean): void;
-declare function getTables(query: ParsedFindQuery): [PrimaryTable, JoinTable[], LateralJoinTable[], CrossJoinTable[]];
+export declare function maybeAddOrderBy(query: ParsedFindQuery, meta: EntityMetadata, alias: string): void;
+export declare function addTablePerClassJoinsAndClassTag(query: ParsedFindQuery, meta: EntityMetadata, alias: string, isPrimary: boolean): void;
+export declare function getTables(query: ParsedFindQuery): [PrimaryTable, JoinTable[], LateralJoinTable[], CrossJoinTable[]];
 //#endregion
-export { CrossJoinTable, JoinTable, LateralJoinTable, ParsedCteClause, ParsedFindQuery, ParsedGroupBy, ParsedOrderBy, ParsedSelect, ParsedTable, PrimaryTable, addTablePerClassJoinsAndClassTag, findFilterField, getTables, maybeAddIdNotNulls, maybeAddOrderBy, parseAlias, parseFindQuery };
+export {};
 //# sourceMappingURL=QueryParser.d.cts.map

package/build/queries/find/QueryParser.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryParser.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.ts"],"mappings":";;;;UA6BiB;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;EAsBA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;;;;UAsBa;EACf;;EAEA;;EAEA;;;;;;;;;;;;;UAce;;EAEf;;EAEA;IAAY;IAAoB;;;EAEhC;IAAS;IAAa;IAAa;;IAA+B;IAAa,OAAO;;;EAEtF;;;;;UAMe;EACf;EACA;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;IAAa;IAAgB;;;KAGnB,cAAc,eAAe,YAAY,iBAAiB;UAErD;EACf;EACA;EACA,OAAO;;KAGG;EAAkB;EAAe;;EAAqB;;KAEtD,wBAAwB;KAC/B;EAA6B;EAAa;EAAiB;;;UAG/C;EACf,SAAS;;EAET,QAAQ;;EAER,YAAY;;EAEZ,WAAW;;EAEX,UAAU;;EAEV,OAAO;;;;;;;;iBASO,eACd,MAAM,gBACN,aACA;EACE,aAAa;EACb;EACA;EACA;EACA;EACA;EACA;IAED;;;;;;;;;;;;iBAqhBa,mBAAmB,OAAO;;iBAgC1B,WAAW;;iBAKX,gBAAgB,MAAM,gBAAgB,eAAe;EAAU;;;iBAU/D,gBAAgB,OAAO,iBAAiB,MAAM,gBAAgB;iBAiB9D,iCACd,OAAO,iBACP,MAAM,gBACN,eACA;iBA8Fc,UAAU,OAAO,mBAAmB,cAAc,aAAa,oBAAoB"}
+{"version":3,"file":"QueryParser.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.ts"],"mappings":";;;;iBA6BiB;EACf;EACA;EACA;;iBAGe;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;EAsBA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;;;;iBAsBa;EACf;;EAEA;;EAEA;;;;;;;;;;;;;iBAce;;EAEf;;EAEA;IAAY;IAAoB;;;EAEhC;IAAS;IAAa;IAAa;;IAA+B;IAAa,OAAO;;;EAEtF;;;;;iBAMe;EACf;EACA;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;IAAa;IAAgB;;;YAGnB,cAAc,eAAe,YAAY,iBAAiB;iBAErD;EACf;EACA;EACA,OAAO;;YAGG;EAAkB;EAAe;;EAAqB;;YAEtD,wBAAwB;KAC/B;EAA6B;EAAa;EAAiB;;;iBAG/C;EACf,SAAS;;EAET,QAAQ;;EAER,YAAY;;EAEZ,WAAW;;EAEX,UAAU;;EAEV,OAAO;;;;;;;;wBASO,eACd,MAAM,gBACN,aACA;EACE,aAAa;EACb;EACA;EACA;EACA;EACA;EACA;IAED;;;;;;;;;;;;wBAqhBa,mBAAmB,OAAO;;wBAgC1B,WAAW;;wBAKX,gBAAgB,MAAM,gBAAgB,eAAe;EAAU;;;wBAU/D,gBAAgB,OAAO,iBAAiB,MAAM,gBAAgB;wBAiB9D,iCACd,OAAO,iBACP,MAAM,gBACN,eACA;wBA8Fc,UAAU,OAAO,mBAAmB,cAAc,aAAa,oBAAoB"}

package/build/queries/find/QueryParser.d.mts

@@ -2,12 +2,12 @@ import { ParsedExpressionFilter } from "../parsedConditions.mjs";
 import { ExpressionFilter, OrderBy } from "./EntityFilter.mjs";
 import { EntityMetadata, Field } from "../../EntityMetadata.mjs";
 //#region src/queries/find/QueryParser.d.ts
-interface PrimaryTable {
+export interface PrimaryTable {
   join: "primary";
   alias: string;
   table: string;
 }
-interface JoinTable {
+export interface JoinTable {
   join: "inner" | "outer";
   alias: string;
   table: string;
@@ -62,7 +62,7 @@ interface JoinTable {
  * GROUP BY a.id
  * ```
  */
-interface CrossJoinTable {
+export interface CrossJoinTable {
   join: "cross";
   /** The new alias for the joined table. */
   alias: string;
@@ -80,7 +80,7 @@ interface CrossJoinTable {
  * )
  * ```
  */
-interface ParsedCteClause {
+export interface ParsedCteClause {
   /** The new alias for the CTE, i.e. `_find` in the above query. */
   alias: string;
   /** The columns, i.e. `tag, arg0, arg1` in the above query. */
@@ -103,7 +103,7 @@ interface ParsedCteClause {
 /**
  * Creates `LATERAL JOIN`s, currently used by `findCount` and JSON preloading.
  */
-interface LateralJoinTable {
+export interface LateralJoinTable {
   join: "lateral";
   alias: string;
   /** Used for join dependency tracking. */
@@ -118,26 +118,26 @@ interface LateralJoinTable {
     offset?: number;
   };
 }
-type ParsedTable = PrimaryTable | JoinTable | CrossJoinTable | LateralJoinTable;
-interface ParsedOrderBy {
+export type ParsedTable = PrimaryTable | JoinTable | CrossJoinTable | LateralJoinTable;
+export interface ParsedOrderBy {
   alias: string;
   column: string;
   order: OrderBy;
 }
-type ParsedGroupBy = {
+export type ParsedGroupBy = {
   alias: string;
   column: string;
 } | {
   expression: string;
 };
-type ParsedSelect = string | ParsedSelectWithBindings;
+export type ParsedSelect = string | ParsedSelectWithBindings;
 type ParsedSelectWithBindings = {
   sql: string;
   bindings: any[];
   aliases: string[];
 };
 /** The result of parsing an `em.find` filter. */
-interface ParsedFindQuery {
+export interface ParsedFindQuery {
   selects: ParsedSelect[];
   /** The primary table plus any joins. */
   tables: ParsedTable[];
@@ -156,7 +156,7 @@ interface ParsedFindQuery {
  * The main execution flow is:
  * parseFindQuery -> beforeFind plugins -> optimizeCollectionJoins -> pruneUnusedJoins -> execute SQL.
  */
-declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
+export declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
   conditions?: ExpressionFilter;
   orderBy?: any;
   pruneJoins?: boolean;
@@ -176,17 +176,17 @@ declare function parseFindQuery(meta: EntityMetadata, filter: any, opts?: {
  * to do an `OR` across two different children (which queries both children being
  * OUTER JOINs, and detecting that case seemed complicated).
  */
-declare function maybeAddIdNotNulls(query: ParsedFindQuery): void;
+export declare function maybeAddIdNotNulls(query: ParsedFindQuery): void;
 /** Returns the `a` from `"a".*`. */
-declare function parseAlias(alias: string): string;
+export declare function parseAlias(alias: string): string;
 /** Finds a filter field by fieldName or generated fieldIdName. */
-declare function findFilterField(meta: EntityMetadata, key: string): (Field & {
+export declare function findFilterField(meta: EntityMetadata, key: string): (Field & {
   aliasSuffix: string;
 }) | undefined;
 /** Adds any user-configured default order, plus an "always order by id" for determinism. */
-declare function maybeAddOrderBy(query: ParsedFindQuery, meta: EntityMetadata, alias: string): void;
-declare function addTablePerClassJoinsAndClassTag(query: ParsedFindQuery, meta: EntityMetadata, alias: string, isPrimary: boolean): void;
-declare function getTables(query: ParsedFindQuery): [PrimaryTable, JoinTable[], LateralJoinTable[], CrossJoinTable[]];
+export declare function maybeAddOrderBy(query: ParsedFindQuery, meta: EntityMetadata, alias: string): void;
+export declare function addTablePerClassJoinsAndClassTag(query: ParsedFindQuery, meta: EntityMetadata, alias: string, isPrimary: boolean): void;
+export declare function getTables(query: ParsedFindQuery): [PrimaryTable, JoinTable[], LateralJoinTable[], CrossJoinTable[]];
 //#endregion
-export { CrossJoinTable, JoinTable, LateralJoinTable, ParsedCteClause, ParsedFindQuery, ParsedGroupBy, ParsedOrderBy, ParsedSelect, ParsedTable, PrimaryTable, addTablePerClassJoinsAndClassTag, findFilterField, getTables, maybeAddIdNotNulls, maybeAddOrderBy, parseAlias, parseFindQuery };
+export {};
 //# sourceMappingURL=QueryParser.d.mts.map

package/build/queries/find/QueryParser.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryParser.d.mts","names":[],"sources":["../../../src/queries/find/QueryParser.ts"],"mappings":";;;;UA6BiB;EACf;EACA;EACA;;UAGe;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;EAsBA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;;;;UAsBa;EACf;;EAEA;;EAEA;;;;;;;;;;;;;UAce;;EAEf;;EAEA;IAAY;IAAoB;;;EAEhC;IAAS;IAAa;IAAa;;IAA+B;IAAa,OAAO;;;EAEtF;;;;;UAMe;EACf;EACA;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;IAAa;IAAgB;;;KAGnB,cAAc,eAAe,YAAY,iBAAiB;UAErD;EACf;EACA;EACA,OAAO;;KAGG;EAAkB;EAAe;;EAAqB;;KAEtD,wBAAwB;KAC/B;EAA6B;EAAa;EAAiB;;;UAG/C;EACf,SAAS;;EAET,QAAQ;;EAER,YAAY;;EAEZ,WAAW;;EAEX,UAAU;;EAEV,OAAO;;;;;;;;iBASO,eACd,MAAM,gBACN,aACA;EACE,aAAa;EACb;EACA;EACA;EACA;EACA;EACA;IAED;;;;;;;;;;;;iBAqhBa,mBAAmB,OAAO;;iBAgC1B,WAAW;;iBAKX,gBAAgB,MAAM,gBAAgB,eAAe;EAAU;;;iBAU/D,gBAAgB,OAAO,iBAAiB,MAAM,gBAAgB;iBAiB9D,iCACd,OAAO,iBACP,MAAM,gBACN,eACA;iBA8Fc,UAAU,OAAO,mBAAmB,cAAc,aAAa,oBAAoB"}
+{"version":3,"file":"QueryParser.d.mts","names":[],"sources":["../../../src/queries/find/QueryParser.ts"],"mappings":";;;;iBA6BiB;EACf;EACA;EACA;;iBAGe;EACf;EACA;EACA;EACA;EACA;EACA;;;;;;;;;;;;;;;;;;;;;;EAsBA;;IAEE;;IAEA;;IAEA;;;;;;;;;;;;;;;;;;;;;iBAsBa;EACf;;EAEA;;EAEA;;;;;;;;;;;;;iBAce;;EAEf;;EAEA;IAAY;IAAoB;;;EAEhC;IAAS;IAAa;IAAa;;IAA+B;IAAa,OAAO;;;EAEtF;;;;;iBAMe;EACf;EACA;;EAEA;;EAEA;;EAEA,OAAO;;EAEP;IAAa;IAAgB;;;YAGnB,cAAc,eAAe,YAAY,iBAAiB;iBAErD;EACf;EACA;EACA,OAAO;;YAGG;EAAkB;EAAe;;EAAqB;;YAEtD,wBAAwB;KAC/B;EAA6B;EAAa;EAAiB;;;iBAG/C;EACf,SAAS;;EAET,QAAQ;;EAER,YAAY;;EAEZ,WAAW;;EAEX,UAAU;;EAEV,OAAO;;;;;;;;wBASO,eACd,MAAM,gBACN,aACA;EACE,aAAa;EACb;EACA;EACA;EACA;EACA;EACA;IAED;;;;;;;;;;;;wBAqhBa,mBAAmB,OAAO;;wBAgC1B,WAAW;;wBAKX,gBAAgB,MAAM,gBAAgB,eAAe;EAAU;;;wBAU/D,gBAAgB,OAAO,iBAAiB,MAAM,gBAAgB;wBAiB9D,iCACd,OAAO,iBACP,MAAM,gBACN,eACA;wBA8Fc,UAAU,OAAO,mBAAmB,cAAc,aAAa,oBAAoB"}

package/build/queries/find/QueryParser.pruning.d.cts

@@ -1,8 +1,7 @@
 import { ParsedFindQuery } from "./QueryParser.cjs";
 //#region src/queries/find/QueryParser.pruning.d.ts
-declare function pruneUnusedJoins(parsed: ParsedFindQuery, keepAliases: string[]): void;
+export declare function pruneUnusedJoins(parsed: ParsedFindQuery, keepAliases: string[]): void;
 /** Returns true if a raw select expression references `alias.column` or the whole-row `alias`. */
-declare function selectReferencesAlias(select: string, alias: string): boolean;
+export declare function selectReferencesAlias(select: string, alias: string): boolean;
 //#endregion
-export { pruneUnusedJoins, selectReferencesAlias };
 //# sourceMappingURL=QueryParser.pruning.d.cts.map

package/build/queries/find/QueryParser.pruning.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryParser.pruning.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.pruning.ts"],"mappings":";;iBAKgB,iBAAiB,QAAQ,iBAAiB;;iBAkG1C,sBAAsB,gBAAgB"}
+{"version":3,"file":"QueryParser.pruning.d.cts","names":[],"sources":["../../../src/queries/find/QueryParser.pruning.ts"],"mappings":";;wBAKgB,iBAAiB,QAAQ,iBAAiB;;wBAkG1C,sBAAsB,gBAAgB"}

package/build/queries/find/QueryParser.pruning.d.mts

@@ -1,8 +1,7 @@
 import { ParsedFindQuery } from "./QueryParser.mjs";
 //#region src/queries/find/QueryParser.pruning.d.ts
-declare function pruneUnusedJoins(parsed: ParsedFindQuery, keepAliases: string[]): void;
+export declare function pruneUnusedJoins(parsed: ParsedFindQuery, keepAliases: string[]): void;
 /** Returns true if a raw select expression references `alias.column` or the whole-row `alias`. */
-declare function selectReferencesAlias(select: string, alias: string): boolean;
+export declare function selectReferencesAlias(select: string, alias: string): boolean;
 //#endregion
-export { pruneUnusedJoins, selectReferencesAlias };
 //# sourceMappingURL=QueryParser.pruning.d.mts.map

package/build/queries/find/QueryParser.pruning.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryParser.pruning.d.mts","names":[],"sources":["../../../src/queries/find/QueryParser.pruning.ts"],"mappings":";;iBAKgB,iBAAiB,QAAQ,iBAAiB;;iBAkG1C,sBAAsB,gBAAgB"}
+{"version":3,"file":"QueryParser.pruning.d.mts","names":[],"sources":["../../../src/queries/find/QueryParser.pruning.ts"],"mappings":";;wBAKgB,iBAAiB,QAAQ,iBAAiB;;wBAkG1C,sBAAsB,gBAAgB"}

package/build/queries/find/QueryVisitor.d.cts

@@ -15,10 +15,10 @@ interface Visitor {
  *
  * If the visitor returns null, the condition or expression will be removed from the tree.
  */
-declare function visitConditions(query: ParsedFindQuery, visitor: Visitor): void;
+export declare function visitConditions(query: ParsedFindQuery, visitor: Visitor): void;
 /** Returns whether a parsed query contains a condition tree that cannot match any database row. */
-declare function isQueryProvablyEmpty(query: ParsedFindQuery): boolean;
-declare function visitFilter(pc: ParsedExpressionCondition, visitor: Visitor): void;
+export declare function isQueryProvablyEmpty(query: ParsedFindQuery): boolean;
+export declare function visitFilter(pc: ParsedExpressionCondition, visitor: Visitor): void;
 //#endregion
-export { isQueryProvablyEmpty, visitConditions, visitFilter };
+export {};
 //# sourceMappingURL=QueryVisitor.d.cts.map

package/build/queries/find/QueryVisitor.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryVisitor.d.cts","names":[],"sources":["../../../src/queries/find/QueryVisitor.ts"],"mappings":";;;;UAUU;EACR,UAAU,GAAG,yBAAyB;EACtC,UAAU,GAAG,eAAe,eAAe;EAC3C,UAAU,GAAG,kBAAkB,kBAAkB,yBAAyB;;;;;;;;;;iBAW5D,gBAAgB,OAAO,iBAAiB,SAAS;;iBAmBjD,qBAAqB,OAAO;iBAe5B,YAAY,IAAI,2BAA2B,SAAS"}
+{"version":3,"file":"QueryVisitor.d.cts","names":[],"sources":["../../../src/queries/find/QueryVisitor.ts"],"mappings":";;;;UAUU;EACR,UAAU,GAAG,yBAAyB;EACtC,UAAU,GAAG,eAAe,eAAe;EAC3C,UAAU,GAAG,kBAAkB,kBAAkB,yBAAyB;;;;;;;;;;wBAW5D,gBAAgB,OAAO,iBAAiB,SAAS;;wBAmBjD,qBAAqB,OAAO;wBAe5B,YAAY,IAAI,2BAA2B,SAAS"}

package/build/queries/find/QueryVisitor.d.mts

@@ -15,10 +15,10 @@ interface Visitor {
  *
  * If the visitor returns null, the condition or expression will be removed from the tree.
  */
-declare function visitConditions(query: ParsedFindQuery, visitor: Visitor): void;
+export declare function visitConditions(query: ParsedFindQuery, visitor: Visitor): void;
 /** Returns whether a parsed query contains a condition tree that cannot match any database row. */
-declare function isQueryProvablyEmpty(query: ParsedFindQuery): boolean;
-declare function visitFilter(pc: ParsedExpressionCondition, visitor: Visitor): void;
+export declare function isQueryProvablyEmpty(query: ParsedFindQuery): boolean;
+export declare function visitFilter(pc: ParsedExpressionCondition, visitor: Visitor): void;
 //#endregion
-export { isQueryProvablyEmpty, visitConditions, visitFilter };
+export {};
 //# sourceMappingURL=QueryVisitor.d.mts.map

package/build/queries/find/QueryVisitor.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"QueryVisitor.d.mts","names":[],"sources":["../../../src/queries/find/QueryVisitor.ts"],"mappings":";;;;UAUU;EACR,UAAU,GAAG,yBAAyB;EACtC,UAAU,GAAG,eAAe,eAAe;EAC3C,UAAU,GAAG,kBAAkB,kBAAkB,yBAAyB;;;;;;;;;;iBAW5D,gBAAgB,OAAO,iBAAiB,SAAS;;iBAmBjD,qBAAqB,OAAO;iBAe5B,YAAY,IAAI,2BAA2B,SAAS"}
+{"version":3,"file":"QueryVisitor.d.mts","names":[],"sources":["../../../src/queries/find/QueryVisitor.ts"],"mappings":";;;;UAUU;EACR,UAAU,GAAG,yBAAyB;EACtC,UAAU,GAAG,eAAe,eAAe;EAC3C,UAAU,GAAG,kBAAkB,kBAAkB,yBAAyB;;;;;;;;;;wBAW5D,gBAAgB,OAAO,iBAAiB,SAAS;;wBAmBjD,qBAAqB,OAAO;wBAe5B,YAAY,IAAI,2BAA2B,SAAS"}

package/build/queries/find/buildFindQuery.d.cts

@@ -10,15 +10,15 @@ type QuerySettings = {
  * In theory this should be implemented within each Driver, but the logic will be largely
  * the same for different dbs.
  */
-declare function buildRawQuery(parsed: ParsedFindQuery, settings: QuerySettings): {
+export declare function buildRawQuery(parsed: ParsedFindQuery, settings: QuerySettings): {
   sql: string;
   bindings: readonly any[];
 };
 /** Creates the `WITH alias (...)` SQL for the given `cte`. */
-declare function buildCteSql(cte: ParsedCteClause): {
+export declare function buildCteSql(cte: ParsedCteClause): {
   sql: string;
   bindings: readonly any[];
 };
 //#endregion
-export { buildCteSql, buildRawQuery };
+export {};
 //# sourceMappingURL=buildFindQuery.d.cts.map

package/build/queries/find/buildFindQuery.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"buildFindQuery.d.cts","names":[],"sources":["../../../src/queries/find/buildFindQuery.ts"],"mappings":";;KAKK;EAAkB;EAAgB;;;;;;;;iBAQvB,cACd,QAAQ,iBACR,UAAU;EACP;EAAa;;;iBA+HF,YAAY,KAAK;EAAoB;EAAa"}
+{"version":3,"file":"buildFindQuery.d.cts","names":[],"sources":["../../../src/queries/find/buildFindQuery.ts"],"mappings":";;KAKK;EAAkB;EAAgB;;;;;;;;wBAQvB,cACd,QAAQ,iBACR,UAAU;EACP;EAAa;;;wBA+HF,YAAY,KAAK;EAAoB;EAAa"}

package/build/queries/find/buildFindQuery.d.mts

@@ -10,15 +10,15 @@ type QuerySettings = {
  * In theory this should be implemented within each Driver, but the logic will be largely
  * the same for different dbs.
  */
-declare function buildRawQuery(parsed: ParsedFindQuery, settings: QuerySettings): {
+export declare function buildRawQuery(parsed: ParsedFindQuery, settings: QuerySettings): {
   sql: string;
   bindings: readonly any[];
 };
 /** Creates the `WITH alias (...)` SQL for the given `cte`. */
-declare function buildCteSql(cte: ParsedCteClause): {
+export declare function buildCteSql(cte: ParsedCteClause): {
   sql: string;
   bindings: readonly any[];
 };
 //#endregion
-export { buildCteSql, buildRawQuery };
+export {};
 //# sourceMappingURL=buildFindQuery.d.mts.map

package/build/queries/find/buildFindQuery.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"buildFindQuery.d.mts","names":[],"sources":["../../../src/queries/find/buildFindQuery.ts"],"mappings":";;KAKK;EAAkB;EAAgB;;;;;;;;iBAQvB,cACd,QAAQ,iBACR,UAAU;EACP;EAAa;;;iBA+HF,YAAY,KAAK;EAAoB;EAAa"}
+{"version":3,"file":"buildFindQuery.d.mts","names":[],"sources":["../../../src/queries/find/buildFindQuery.ts"],"mappings":";;KAKK;EAAkB;EAAgB;;;;;;;;wBAQvB,cACd,QAAQ,iBACR,UAAU;EACP;EAAa;;;wBA+HF,YAAY,KAAK;EAAoB;EAAa"}