typeorm-extensions 2.1.0 → 2.2.0-rc.0

package/dist/extensions/typed/typed-where/typed-where-array.extension.d.ts

@@ -2,6 +2,7 @@ import '../../where-array.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { ArgsType } from '../../../types/util-types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe conditions on PostgreSQL array columns: the column comes from an entity property.
  * See {@link WhereArrayMethods}.
@@ -12,43 +13,43 @@ export interface TypedWhereArrayMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
      */
-    andWhereArrayContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column @> :values` condition (PostgreSQL): the array column contains every value.
      */
-    orWhereArrayContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Sets WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayContainedByTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      */
-    andWhereArrayContainedByTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column <@ :values` condition (PostgreSQL): every element of the array column is one of the values.
      */
-    orWhereArrayContainedByTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Sets WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereArrayOverlapsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      */
-    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column && :values` condition (PostgreSQL): the array column has at least one of the values.
      */
-    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereArrayMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-array.extension.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-array.extension");
 const typeorm_1 = require("typeorm");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
+const sql_utils_1 = require("../../../utils/sql.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
 // patching
@@ -36,6 +37,37 @@ function attachWhereArrayTyped(builder, method, where, values, arrayType) {
         return builder;
     }
     const key = (0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, `${method}Typed`);
+    if ((0, query_builder_utils_1.isTypedJsonPath)(builder, where)) {
+        return attachWhereJsonArray(builder, method, where, values, arrayType);
+    }
     // .andWhereArrayContains(`"table"."column"`, ['value'])
     return builder[method](key, values, arrayType);
 }
+const JSON_ARRAY_METHOD = /^(where|andWhere|orWhere)Array(Contains|ContainedBy|Overlaps)$/;
+const JSON_ARRAY_OPERATORS = { Contains: '@>', ContainedBy: '<@', Overlaps: '?|' };
+/**
+ * The array conditions on an array inside a JSON column, with jsonb operators: `@>` and `<@` against the
+ * values as a JSON array, and `?|` (any of the strings is an element) for the overlap. Empty arrays keep
+ * PostgreSQL's semantics, as for array columns.
+ */
+function attachWhereJsonArray(builder, method, where, values, arrayType) {
+    const methodName = `${method}Typed`;
+    const [, whereMethod, condition] = JSON_ARRAY_METHOD.exec(method);
+    if (!Array.isArray(values)) {
+        throw new TypeError(`${methodName} expects an array of values, got ${values}`);
+    }
+    if (arrayType !== undefined) {
+        throw new TypeError(`${methodName}: arrayType is for array columns, not for an array inside a JSON column`);
+    }
+    const jsonArray = `CAST(${(0, query_builder_utils_1.getTypedSingleColumnKey)(builder, where, methodName, { accessor: 'json' })} AS jsonb)`;
+    const paramName = (0, sql_utils_1.createUniqueParameterName)(whereMethod);
+    // a string or an object at the path isn't an array, but <@ and ?| would match it
+    const onArray = (condition) => `(jsonb_typeof(${jsonArray}) = 'array' AND ${condition})`;
+    if (condition === 'Overlaps') {
+        if (!values.every((value) => typeof value === 'string')) {
+            throw new TypeError(`${methodName} on an array inside a JSON column takes strings: the ?| operator matches string elements`);
+        }
+        return builder[whereMethod](onArray(`${jsonArray} ?| CAST(:${paramName} AS text[])`), { [paramName]: values });
+    }
+    return builder[whereMethod](onArray(`${jsonArray} ${JSON_ARRAY_OPERATORS[condition]} CAST(:${paramName} AS jsonb)`), { [paramName]: JSON.stringify(values) });
+}

package/dist/extensions/typed/typed-where/typed-where-ilike.extension.d.ts

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { SearchSelector, TypedILikeOptions, TypedSearchOptions } from '../../../types/extensions/search.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Case-insensitive search methods: `ILIKE` on PostgreSQL, `LIKE` on MySQL / MariaDB and SQLite.
  * `%`, `_` and `\` in the value are escaped, and a blank value adds no condition.
@@ -13,17 +14,17 @@ export interface TypedWhereILikeMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereILikeTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    whereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
     /**
      * Adds new AND WHERE `column ILIKE :pattern` condition in the query builder.
      * `null`, `undefined` or a blank value adds no condition.
      */
-    andWhereILikeTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    andWhereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
     /**
      * Adds new OR WHERE `column ILIKE :pattern` condition in the query builder.
      * `null`, `undefined` or a blank value adds no condition.
      */
-    orWhereILikeTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    orWhereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
     /**
      * Sets WHERE `(col1 ILIKE :pattern OR col2 ILIKE :pattern …)` condition in the query builder:
      * one group, one parameter for every column. A selector is a typed callback (it may select
@@ -32,17 +33,17 @@ export interface TypedWhereILikeMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereSearchTyped<Type extends ObjectLiteral = Entity>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    whereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
     /**
      * Adds new AND WHERE `(col1 ILIKE :pattern OR col2 ILIKE :pattern …)` condition in the query builder.
      * A value shorter than `options.minLength` (default 1, after trimming) adds no condition.
      */
-    andWhereSearchTyped<Type extends ObjectLiteral = Entity>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    andWhereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
     /**
      * Adds new OR WHERE `(col1 ILIKE :pattern OR col2 ILIKE :pattern …)` condition in the query builder.
      * A value shorter than `options.minLength` (default 1, after trimming) adds no condition.
      */
-    orWhereSearchTyped<Type extends ObjectLiteral = Entity>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    orWhereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereILikeMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-is-any.extension.d.ts

@@ -2,6 +2,7 @@ import '../../where-is-any.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { TypedArrayArg, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 export interface TypedWhereIsAnyMethods<Entity extends ObjectLiteral> {
     /**
      * Sets WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
@@ -10,30 +11,30 @@ export interface TypedWhereIsAnyMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    whereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
      */
-    andWhereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    andWhereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column = ANY(:array)` condition in the query builder (PostgreSQL).
      */
-    orWhereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    orWhereIsAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
     /**
      * Sets WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL):
      * the column differs from every value of the array.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    whereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
     /**
      * Adds new AND WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
      */
-    andWhereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    andWhereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
     /**
      * Adds new OR WHERE `column <> ALL(:array)` condition in the query builder (PostgreSQL).
      */
-    orWhereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
+    orWhereIsNotAnyTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereIsAnyMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-is-distinct-from.extension.d.ts

@@ -1,6 +1,7 @@
 import '../../where-is-distinct-from.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe null-safe comparisons: the column comes from an entity property.
  * See {@link WhereDistinctMethods}.
@@ -11,29 +12,29 @@ export interface TypedWhereDistinctMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    whereIsDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new AND WHERE `column IS DISTINCT FROM :value` condition: the column differs from the value, `NULL` included.
      */
-    andWhereIsDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    andWhereIsDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new OR WHERE `column IS DISTINCT FROM :value` condition: the column differs from the value, `NULL` included.
      */
-    orWhereIsDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    orWhereIsDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Sets WHERE `column IS NOT DISTINCT FROM :value` condition: the column equals the value, `NULL` included.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsNotDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    whereIsNotDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new AND WHERE `column IS NOT DISTINCT FROM :value` condition: the column equals the value, `NULL` included.
      */
-    andWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    andWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new OR WHERE `column IS NOT DISTINCT FROM :value` condition: the column equals the value, `NULL` included.
      */
-    orWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    orWhereIsNotDistinctFromTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereDistinctMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-is-in.extension.d.ts

@@ -2,35 +2,36 @@ import '../../where-is-in.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { TypedArrayArg, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 export interface TypedWhereIsInMethods<Entity extends ObjectLiteral> {
     /**
      * Sets WHERE IN condition in the query builder.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    whereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
     /**
      * Adds new AND WHERE IN condition in the query builder.
      */
-    andWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    andWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
     /**
      * Adds new OR WHERE IN condition in the query builder.
      */
-    orWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    orWhereIsInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
     /**
      * Sets WHERE NOT IN condition in the query builder.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    whereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
     /**
      * Adds new AND WHERE NOT IN condition in the query builder.
      */
-    andWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    andWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
     /**
      * Adds new OR WHERE NOT IN condition in the query builder.
      */
-    orWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, array?: TypedArrayArg<Type, Value>): this;
+    orWhereIsNotInTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, array?: TypedArrayArg<Type, Value>): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereIsInMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-json.extension.d.ts

@@ -1,6 +1,7 @@
 import '../../where-json.extension';
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe conditions on PostgreSQL `jsonb` / `json` columns: the column comes from an entity property.
  * See {@link WhereJsonMethods}.
@@ -11,29 +12,29 @@ export interface TypedWhereJsonMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereJsonContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    whereJsonContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new AND WHERE `column @> :value` condition (PostgreSQL): the JSON document contains `value`.
      */
-    andWhereJsonContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    andWhereJsonContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Adds new OR WHERE `column @> :value` condition (PostgreSQL): the JSON document contains `value`.
      */
-    orWhereJsonContainsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
+    orWhereJsonContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: unknown): this;
     /**
      * Sets WHERE `column ? :key` condition (PostgreSQL): the JSON object has the top-level key.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereJsonHasKeyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
+    whereJsonHasKeyTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
     /**
      * Adds new AND WHERE `column ? :key` condition (PostgreSQL): the JSON object has the top-level key.
      */
-    andWhereJsonHasKeyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
+    andWhereJsonHasKeyTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
     /**
      * Adds new OR WHERE `column ? :key` condition (PostgreSQL): the JSON object has the top-level key.
      */
-    orWhereJsonHasKeyTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
+    orWhereJsonHasKeyTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, key: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereJsonMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-lower.extension.d.ts

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { TypedLowerOptions } from '../../../types/extensions/search.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Case-insensitive equality: `LOWER(column) = LOWER(:value)`. `options.normalize` changes the
  * wrapping of both sides, e.g. `(sql) => \`LOWER(TRIM(${sql}))\``, to match an expression index.
@@ -12,34 +13,34 @@ export interface TypedWhereLowerMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereLowerEqualsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
+    whereLowerEqualsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
     /**
      * Adds new AND WHERE `LOWER(column) = LOWER(:value)` condition in the query builder.
      * `null` / `undefined` matches nothing (`FALSE`).
      */
-    andWhereLowerEqualsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
+    andWhereLowerEqualsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
     /**
      * Adds new OR WHERE `LOWER(column) = LOWER(:value)` condition in the query builder.
      * `null` / `undefined` matches nothing (`FALSE`).
      */
-    orWhereLowerEqualsTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
+    orWhereLowerEqualsTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedLowerOptions): this;
     /**
      * Sets WHERE `LOWER(column) IN (LOWER(:v1), LOWER(:v2), …)` condition in the query builder.
      * An empty or missing array matches nothing (`FALSE`), like `whereIsIn`.
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereIsInLowerTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
+    whereIsInLowerTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
     /**
      * Adds new AND WHERE `LOWER(column) IN (LOWER(:v1), LOWER(:v2), …)` condition in the query builder.
      * An empty or missing array matches nothing (`FALSE`).
      */
-    andWhereIsInLowerTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
+    andWhereIsInLowerTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
     /**
      * Adds new OR WHERE `LOWER(column) IN (LOWER(:v1), LOWER(:v2), …)` condition in the query builder.
      * An empty or missing array matches nothing (`FALSE`).
      */
-    orWhereIsInLowerTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
+    orWhereIsInLowerTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ReadonlyArray<string> | null | undefined, options?: TypedLowerOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereLowerMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where-similar.extension.d.ts

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import type { SimilarityScoreOptions, TypedSimilarOptions } from '../../../types/extensions/search.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Trigram similarity conditions (PostgreSQL, `pg_trgm` extension). The column is the left operand,
  * the form a `gin_trgm_ops` / `gist_trgm_ops` index on the column can be used for.
@@ -13,17 +14,17 @@ export interface TypedWhereSimilarMethods<Entity extends ObjectLiteral> {
      * If you had previously WHERE expression defined,
      * calling this function will override previously set WHERE conditions.
      */
-    whereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    whereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
     /**
      * Adds new AND WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
      * A blank term adds no condition.
      */
-    andWhereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    andWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
     /**
      * Adds new OR WHERE `column % :term` condition in the query builder (PostgreSQL, pg_trgm).
      * A blank term adds no condition.
      */
-    orWhereSimilarTyped<Type extends ObjectLiteral = Entity>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
+    orWhereSimilarTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, options?: TypedSimilarOptions): this;
 }
 /** Trigram similarity score selection (PostgreSQL, `pg_trgm` extension). */
 export interface TypedSimilarityScoreMethods<Entity extends ObjectLiteral> {
@@ -34,7 +35,7 @@ export interface TypedSimilarityScoreMethods<Entity extends ObjectLiteral> {
      * (`word_similarity(:term, column)`, the score of `column %> :term`).
      * Use a lower-case alias: PostgreSQL folds an unquoted alias in ORDER BY.
      */
-    addSimilarityScoreTyped<Type extends ObjectLiteral = Entity>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, alias: string, options?: SimilarityScoreOptions): this;
+    addSimilarityScoreTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, term: string | null | undefined, alias: string, options?: SimilarityScoreOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereSimilarMethods<ObjectLiteral> {

package/dist/extensions/typed/typed-where/typed-where.extension.d.ts

@@ -1,6 +1,7 @@
 import { ObjectLiteral } from 'typeorm';
 import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/proxy-callback.types';
 import { TypedWhereArgs, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
 /**
  * Typesafe WHERE conditions: the column comes from an entity property.
  * `Type` defaults to the query builder's entity; with the `strictParams` option (see `TypeormExtensionsConfig`)
@@ -13,17 +14,17 @@ export interface TypedWhereMethods<Entity extends ObjectLiteral> {
      * calling this function will override previously set WHERE conditions.
      * Additionally you can add parameters used in where expression.
      */
-    whereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    whereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
     /**
      * Adds new AND WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    andWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    andWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
     /**
      * Adds new OR WHERE condition in the query builder.
      * Additionally you can add parameters used in where expression.
      */
-    orWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, Entity>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
+    orWhereTyped<Type extends ObjectLiteral = UnsetType, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(where: (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, Value>): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereMethods<ObjectLiteral> {

package/dist/extensions/union.extension.d.ts

@@ -0,0 +1,22 @@
+import { ObjectLiteral } from 'typeorm';
+import type { UnionCteOptions, UnionOptions, UnionQuery } from '../types/extensions/union.types';
+export interface UnionMethods {
+    /**
+     * Selects FROM the UNION of `queries`, as `alias`: `FROM ((A) UNION (B)) "alias"`.
+     *
+     * Unlike pasting `${a.getQuery()} UNION ${b.getQuery()}` and merging `getParameters()`, the
+     * parameters of each query are renamed: two queries with a `:status` of their own each keep
+     * their value, where a merged object keeps only the last one. A raw SQL string is used as is,
+     * its placeholders read the parameters of this builder.
+     */
+    fromUnion(queries: readonly UnionQuery[], alias: string, options?: UnionOptions): this;
+    /**
+     * Adds a common table expression (WITH) that is the UNION of `queries`:
+     * `WITH "alias" AS ((A) UNION (B))`. Parameters are renamed as in `fromUnion`.
+     */
+    addCommonTableExpressionUnion(queries: readonly UnionQuery[], alias: string, options?: UnionCteOptions): this;
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends UnionMethods {
+    }
+}

package/dist/extensions/union.extension.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const prototype_utils_1 = require("../utils/prototype.utils");
+const parameter_utils_1 = require("../utils/parameter.utils");
+const sql_utils_1 = require("../utils/sql.utils");
+/* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-unused-vars */
+// patching
+const extension = {
+    prototype: {
+        fromUnion(queries, alias, options) {
+            return this.from(`(${unionSql(this, 'fromUnion', queries, options)})`, alias);
+        },
+        addCommonTableExpressionUnion(queries, alias, options) {
+            const { all, ...cteOptions } = options !== null && options !== void 0 ? options : {};
+            return this.addCommonTableExpression(unionSql(this, 'addCommonTableExpressionUnion', queries, { all }), alias, cteOptions);
+        },
+    },
+};
+(0, prototype_utils_1.patchPrototype)(typeorm_1.SelectQueryBuilder, extension);
+// implementation
+/** The UNION of `queries`, with the parameters of each set on `builder` under unique names. */
+function unionSql(builder, methodName, queries, options) {
+    if (!queries.length) {
+        throw new TypeError(`${methodName}: no queries to union`);
+    }
+    const sqlite = (0, sql_utils_1.isSqliteLikeDriver)((0, sql_utils_1.getDriverType)(builder));
+    const branches = queries.map((query) => {
+        const sql = typeof query === 'string' ? query : bindParameters(builder, query);
+        if (!sqlite) {
+            return `(${sql})`;
+        }
+        // SQLite takes neither parentheses around a part of a UNION nor an ORDER BY / LIMIT inside one
+        // (a query of an entity with a default `orderBy` has an ORDER BY): such a part becomes a subquery.
+        // Only such a part: the recursive part of a CTE can't refer to the CTE from a subquery
+        return ordersOrLimits(query, sql) ? `SELECT * FROM (${sql})` : sql;
+    });
+    return branches.join((options === null || options === void 0 ? void 0 : options.all) ? ' UNION ALL ' : ' UNION ');
+}
+const ORDER_OR_LIMIT = /\b(?:ORDER\s+BY|LIMIT|OFFSET)\b/i;
+function ordersOrLimits(query, sql) {
+    if (typeof query === 'string' || !('expressionMap' in query)) {
+        return ORDER_OR_LIMIT.test(sql);
+    }
+    const { allOrderBys, limit, offset, take, skip } = query.expressionMap;
+    return Object.keys(allOrderBys !== null && allOrderBys !== void 0 ? allOrderBys : {}).length > 0 || [limit, offset, take, skip].some((value) => value !== undefined);
+}
+function bindParameters(builder, query) {
+    const [sql, parameters] = (0, parameter_utils_1.withUniqueParameterNames)(query.getQuery(), query.getParameters());
+    builder.setParameters(parameters);
+    return sql;
+}

package/dist/extensions/where-exists.extension.d.ts

@@ -0,0 +1,50 @@
+import { ObjectLiteral, SelectQueryBuilder, WhereExpressionBuilder } from 'typeorm';
+import type { WhereMethods } from '../types/extensions';
+/**
+ * `EXISTS` conditions. TypeORM has them on `SelectQueryBuilder` only, and keeps its own there;
+ * these add them to `UpdateQueryBuilder` and `DeleteQueryBuilder` with the same SQL. Unlike
+ * TypeORM's, they add the subquery's parameters under unique names.
+ */
+export interface WhereExistsMethods {
+    /** Sets `WHERE EXISTS (subQuery)`, replacing the WHERE conditions set before. */
+    whereExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `AND EXISTS (subQuery)`. */
+    andWhereExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `OR EXISTS (subQuery)`. */
+    orWhereExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+}
+/**
+ * `NOT EXISTS` conditions: the negation of TypeORM's `whereExists`, with the same subquery SQL.
+ * The subquery's parameters are added under unique names, so two subqueries can both use `:status`.
+ */
+export interface WhereNotExistsMethods {
+    /** Sets `WHERE NOT EXISTS (subQuery)`, replacing the WHERE conditions set before. */
+    whereNotExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `AND NOT EXISTS (subQuery)`. */
+    andWhereNotExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+    /** Adds `OR NOT EXISTS (subQuery)`. */
+    orWhereNotExists<SubEntity extends ObjectLiteral>(subQuery: SelectQueryBuilder<SubEntity>): this;
+}
+declare module 'typeorm/query-builder/WhereExpressionBuilder' {
+    interface WhereExpressionBuilder extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> extends WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/UpdateQueryBuilder' {
+    interface UpdateQueryBuilder<Entity extends ObjectLiteral> extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/DeleteQueryBuilder' {
+    interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends WhereExistsMethods, WhereNotExistsMethods {
+    }
+}
+type SubQuery = SelectQueryBuilder<ObjectLiteral>;
+export declare function attachExists<QB extends WhereExpressionBuilder>(builder: QB, method: WhereMethods, subQuery: SubQuery, negate: boolean): QB;
+export {};