typeorm-extensions 2.2.0-rc.6 → 2.2.0-rc.7

package/dist/extensions/cursor-pagination.extension.d.ts

@@ -1,3 +1,4 @@
+import { ObjectLiteral } from 'typeorm';
 import type { CursorPaginationFilter } from '../types/interfaces/cursor-pagination.interface';
 import type { GetManyWithCursorOptions, ListWithCursor } from '../types/extensions/cursor-pagination.types';
 export { InvalidCursorError } from '../utils/cursor.utils';
@@ -14,6 +15,6 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * The query builder itself is not changed. Throws `InvalidCursorError` for a cursor that can't
          * be decoded or was made for another order.
          */
-        getManyWithCursor(cursorFilter: CursorPaginationFilter | null | undefined, options: GetManyWithCursorOptions<Entity>): Promise<ListWithCursor<Entity>>;
+        getManyWithCursor<CursorEntity extends ObjectLiteral = Entity>(this: SelectQueryBuilder<CursorEntity>, cursorFilter: CursorPaginationFilter | null | undefined, options: GetManyWithCursorOptions<CursorEntity>): Promise<ListWithCursor<CursorEntity>>;
     }
 }

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

@@ -3,7 +3,7 @@ import { ObjectLiteral } from 'typeorm';
 import type { ApplyOrderOptions } from '../types/extensions/order.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity> {
-        applyOrder<OrderEntity extends ObjectLiteral>(orderBy: OrderParam<OrderEntity>, options?: ApplyOrderOptions): SelectQueryBuilder<Entity>;
-        applyOrderFilter<OrderEntity extends ObjectLiteral>(orderFilter: OrderFilter<OrderEntity>, options?: ApplyOrderOptions): SelectQueryBuilder<Entity>;
+        applyOrder<OrderEntity extends ObjectLiteral>(orderBy: OrderParam<OrderEntity>, options?: ApplyOrderOptions): this;
+        applyOrderFilter<OrderEntity extends ObjectLiteral>(orderFilter: OrderFilter<OrderEntity>, options?: ApplyOrderOptions): this;
     }
 }

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

@@ -3,6 +3,6 @@ import { ObjectLiteral } from 'typeorm';
 import { ApplyPaginationOptions } from '../types/extensions/pagination.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        applyPaginationFilter(paginationFilter: PaginationFilter, options?: ApplyPaginationOptions): SelectQueryBuilder<Entity>;
+        applyPaginationFilter(paginationFilter: PaginationFilter, options?: ApplyPaginationOptions): this;
     }
 }

package/dist/extensions/period-filter.extension.d.ts

@@ -27,3 +27,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends PeriodFilterMethods {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends PeriodFilterMethods {
+    }
+}

package/dist/extensions/period-filter.extension.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const prototype_utils_1 = require("../utils/prototype.utils");
 const query_builder_utils_1 = require("../utils/query-builder.utils");
 const period_utils_1 = require("../utils/period.utils");
@@ -17,6 +18,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

package/dist/extensions/typed/index.d.ts

@@ -2,6 +2,7 @@ export * from './typed-distinct/typed-distinct.extension';
 export * from './typed-group-by/typed-group-by.extension';
 export * from './typed-having/typed-having.extension';
 export * from './typed-joins/typed-joins.extension';
+export * from './typed-joins/typed-join-and-map.extension';
 export * from './typed-order-by/typed-order-by.extension';
 export * from './typed-select/typed-select.extension';
 export * from './typed-where/typed-where.extension';

package/dist/extensions/typed/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./typed-distinct/typed-distinct.extension"), exports);
 __exportStar(require("./typed-group-by/typed-group-by.extension"), exports);
 __exportStar(require("./typed-having/typed-having.extension"), exports);
 __exportStar(require("./typed-joins/typed-joins.extension"), exports);
+__exportStar(require("./typed-joins/typed-join-and-map.extension"), exports);
 __exportStar(require("./typed-order-by/typed-order-by.extension"), exports);
 __exportStar(require("./typed-select/typed-select.extension"), exports);
 __exportStar(require("./typed-where/typed-where.extension"), exports);

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

@@ -6,10 +6,10 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
         /**
          * Sets the distinct on clause for Postgres.
          */
-        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<KeyProxyCallback<Type>>): SelectQueryBuilder<Entity>;
+        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, ...distinctOn: Array<KeyProxyCallback<Type>>): this;
         /**
          * Sets the distinct on clause for Postgres.
          */
-        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): SelectQueryBuilder<Entity>;
+        distinctOnTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, distinctOn: KeyProxyCallback<Type>): this;
     }
 }

package/dist/extensions/typed/typed-group-by/typed-group-by.extension.d.ts

@@ -12,11 +12,11 @@ export interface TypedGroupByMethods<Entity extends ObjectLiteral> {
      * Sets GROUP BY to the columns the callback selects: `user => user.id`, or several at once,
      * `user => [user.id, user.email]`. Replaces previously set GROUP BY.
      */
-    groupByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
+    groupByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
     /**
      * Adds the columns the callback selects to GROUP BY.
      */
-    addGroupByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
+    addGroupByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: GroupBySelection<Type>, options?: TypedGroupByOptions): this;
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedGroupByMethods<Entity> {

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

@@ -3,7 +3,7 @@ import { DeepUnwrapArray, ProxyColumnValueType } from '../../../types/modules/pr
 import { TypedWhereArgs, TypeOrDefault, UnsetType } from '../../../types/modules/typed-params.types';
 import type { TypedAggregate } from '../../../types/extensions/typed-having.types';
 import type { TypedRoot } from '../../../types/modules/typed-root.types';
-type Selection<Entity extends ObjectLiteral, Type, Value> = (proxy: DeepUnwrapArray<TypeOrDefault<Type, TypedRoot<Entity>>>) => Value;
+type Selection<Root extends ObjectLiteral, Type, Value> = (proxy: DeepUnwrapArray<TypeOrDefault<Type, Root>>) => Value;
 /**
  * A value a column holds. A relation (`u => u.images`), the end of a key path or a JSON object is no column:
  * `COUNT("user"."images")` would fail in the database.
@@ -23,11 +23,11 @@ type AggregateValue<Aggregate, Value> = Aggregate extends 'MIN' | 'MAX' ? Value
  */
 export interface TypedHavingMethods<Entity extends ObjectLiteral> {
     /** Sets HAVING `aggregate(column) condition`, replacing the previous HAVING. */
-    havingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<Entity, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
+    havingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<TypedRoot<Entity, this>, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
     /** Adds AND HAVING `aggregate(column) condition`. */
-    andHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<Entity, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
+    andHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<TypedRoot<Entity, this>, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
     /** Adds OR HAVING `aggregate(column) condition`. */
-    orHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<Entity, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
+    orHavingTyped<Type extends ObjectLiteral = UnsetType, Aggregate extends TypedAggregate = TypedAggregate, Value extends ProxyColumnValueType = ProxyColumnValueType, Operator extends string = string>(aggregate: Aggregate, selection: Selection<TypedRoot<Entity, this>, Type, Value & AggregatedColumn> | CountAll<Aggregate>, conditions: Operator, ...args: TypedWhereArgs<Type, Operator, AggregateValue<Aggregate, Value>>): this;
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedHavingMethods<Entity> {

package/dist/extensions/typed/typed-joins/typed-join-and-map.extension.d.ts

@@ -0,0 +1,19 @@
+import { ObjectLiteral } from 'typeorm';
+import { KeyProxyCallback } from '../../../types/modules/proxy-callback.types';
+import type { JoinAndMapTarget } from '../../../types/extensions/typed-join-and-map.types';
+import type { TypedRoot } from '../../../types/modules/typed-root.types';
+declare module 'typeorm/query-builder/SelectQueryBuilder' {
+    interface SelectQueryBuilder<Entity extends ObjectLiteral> {
+        /**
+         * TypeORM's `leftJoinAndMapOne` with the property to map to picked by a typed callback: `(u) => u.profile` is
+         * `'user.profile'` on the main alias, `(q) => q.photo.owner` is `'photo.owner'` with an alias-keyed root.
+         */
+        leftJoinAndMapOneTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        /** TypeORM's `innerJoinAndMapOne` with the property to map to picked by a typed callback. */
+        innerJoinAndMapOneTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        /** TypeORM's `leftJoinAndMapMany` with the property to map to picked by a typed callback. */
+        leftJoinAndMapManyTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        /** TypeORM's `innerJoinAndMapMany` with the property to map to picked by a typed callback. */
+        innerJoinAndMapManyTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, mapToProperty: KeyProxyCallback<Type>, entity: JoinAndMapTarget, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+    }
+}

package/dist/extensions/typed/typed-joins/typed-join-and-map.extension.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const typeorm_1 = require("typeorm");
+const proxy_key_utils_1 = require("../../../utils/proxy-key.utils");
+// patching
+typeorm_1.SelectQueryBuilder.prototype.leftJoinAndMapOneTyped = function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, 'leftJoinAndMapOne', mapToProperty, entity, alias, condition, parameters);
+};
+typeorm_1.SelectQueryBuilder.prototype.innerJoinAndMapOneTyped = function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, 'innerJoinAndMapOne', mapToProperty, entity, alias, condition, parameters);
+};
+typeorm_1.SelectQueryBuilder.prototype.leftJoinAndMapManyTyped = function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, 'leftJoinAndMapMany', mapToProperty, entity, alias, condition, parameters);
+};
+typeorm_1.SelectQueryBuilder.prototype.innerJoinAndMapManyTyped = function (mapToProperty, entity, alias, condition, parameters) {
+    return addJoinAndMap(this, 'innerJoinAndMapMany', mapToProperty, entity, alias, condition, parameters);
+};
+function addJoinAndMap(query, method, mapToProperty, entity, alias, condition, parameters) {
+    // `() => query.alias`: `(q) => q.photo.owner` needs no main alias, only `(u) => u.profile` does
+    const key = (0, proxy_key_utils_1.getSqlKeyFromProxyCallback)(mapToProperty, () => query.alias, false);
+    return query[method](key, entity, alias, condition, parameters);
+}

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

@@ -3,9 +3,9 @@ import { RelationalKeyProxyCallback } from '../../../types/modules/proxy-callbac
 import type { TypedRoot } from '../../../types/modules/typed-root.types';
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
-        leftJoinTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        innerJoinTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        leftJoinAndSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
-        innerJoinAndSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): SelectQueryBuilder<Entity>;
+        leftJoinTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        innerJoinTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        leftJoinAndSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
+        innerJoinAndSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: RelationalKeyProxyCallback<Type>, alias: string, condition?: string, parameters?: ObjectLiteral): this;
     }
 }

package/dist/extensions/typed/typed-order-by/typed-order-by-array-position.extension.d.ts

@@ -9,11 +9,11 @@ export interface TypedOrderByArrayPositionMethods<Entity extends ObjectLiteral>
      * `array_position(:values, column)`. Rows whose value isn't in `values` come last.
      * Like `orderBy`, it replaces the previous ORDER BY. See `orderByArrayPosition`.
      */
-    orderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
     /**
      * Adds ORDER BY the position of the property's column value in `values` (PostgreSQL), like `addOrderBy`.
      */
-    addOrderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    addOrderByArrayPositionTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> extends TypedOrderByArrayPositionMethods<Entity> {

package/dist/extensions/typed/typed-order-by/typed-order-by.extension.d.ts

@@ -10,10 +10,10 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * If you had previously ORDER BY expression defined,
          * calling this function will override previously set ORDER BY conditions.
          */
-        orderByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): SelectQueryBuilder<Entity>;
+        orderByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): this;
         /**
          * Adds ORDER BY condition in the query builder.
          */
-        addOrderByTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): SelectQueryBuilder<Entity>;
+        addOrderByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType | KeyHolder, order?: 'ASC' | 'DESC', nulls?: 'NULLS FIRST' | 'NULLS LAST', options?: TypedOrderByOptions): this;
     }
 }

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

@@ -1,13 +1,14 @@
 import { ObjectLiteral } from 'typeorm';
+import type { EntityTarget } from 'typeorm';
 import type { WithTypedRoot } from '../../types/modules/typed-root.types';
-type KnownEntity<Entity> = 0 extends 1 & Entity ? ObjectLiteral : Entity;
 declare module 'typeorm/query-builder/SelectQueryBuilder' {
     interface SelectQueryBuilder<Entity extends ObjectLiteral> {
         /**
          * Sets the root of the typed callbacks of the calls that follow, instead of passing it to each of them:
          * the aliases of the query and their entities.
          *
-         * Type-only: returns the builder itself. Call it once; a second call merges the roots.
+         * Type-only: returns the builder itself, marked with the root; its entity type stays. `from()` and `addFrom()`
+         * keep the root, so it may go before them; a second call replaces it.
          *
          * @example
          * type Joins = { checkin: CheckIn; event: Event };
@@ -19,7 +20,28 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          *   .selectTyped((q) => q.checkin.customerId, 'customerId')
          *   .whereTyped((q) => q.event.eventType, '=', type) // instead of whereTyped<Joins>(…)
          */
-        typed<Root extends ObjectLiteral>(): SelectQueryBuilder<WithTypedRoot<KnownEntity<Entity>, Root>>;
+        typed<Root extends ObjectLiteral>(): WithTypedRoot<SelectQueryBuilder<Entity>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data.
+         * Removes all previously set from-s. Keeps the root set with `typed()`.
+         */
+        from<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data.
+         * Removes all previously set from-s. Keeps the root set with `typed()`.
+         */
+        from<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: EntityTarget<T>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data. Keeps the root set with `typed()`.
+         */
+        addFrom<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: (qb: SelectQueryBuilder<any>) => SelectQueryBuilder<any>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
+        /**
+         * Specifies FROM which entity's table select/update/delete will be executed.
+         * Also sets a main string alias of the selection data. Keeps the root set with `typed()`.
+         */
+        addFrom<T extends ObjectLiteral, Root extends ObjectLiteral>(this: WithTypedRoot<unknown, Root>, entityTarget: EntityTarget<T>, aliasName: string): WithTypedRoot<SelectQueryBuilder<T>, Root>;
     }
 }
-export {};

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

@@ -8,28 +8,28 @@ declare module 'typeorm/query-builder/SelectQueryBuilder' {
          * Creates SELECT query.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Creates SELECT query and selects given data.
          * Replaces all previous selections if they exist.
          */
-        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        selectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): this;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: KeyProxyCallback<Type>, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped(this: SelectQueryBuilder<Entity>, selection: string | KeyHolder, selectionAliasName?: string, useQuotes?: boolean): this;
         /**
          * Adds new selection to the SELECT query.
          */
-        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): SelectQueryBuilder<Entity>;
+        addSelectTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(this: SelectQueryBuilder<Entity>, selection: string[] | KeyHolder[] | Array<KeyProxyCallback<Type>>, useQuotes?: boolean): this;
     }
 }

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

@@ -12,7 +12,7 @@ export interface TypedPeriodFilterMethods<Entity extends ObjectLiteral> {
      * Both ends are inclusive unless `options.includeFrom` / `options.includeTo` is `false`.
      * A date-only string (`'2024-01-31'`) stands for the whole day: `periodTo: '2024-01-31'` → `column < '2024-02-01'`.
      */
-    applyPeriodFilterTyped<Type extends ObjectLiteral = TypedRoot<Entity>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
+    applyPeriodFilterTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selection: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, periodFilter: PeriodFilter | null | undefined, options?: ApplyPeriodOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedPeriodFilterMethods<ObjectLiteral> {
@@ -30,3 +30,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedPeriodFilterMethods<Entity> {
+    }
+}

package/dist/extensions/typed/typed-where/typed-period-filter.extension.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../period-filter.extension");
 const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const period_utils_1 = require("../../../utils/period.utils");
@@ -19,6 +20,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

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

@@ -13,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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayContainedByTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    whereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    andWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
+    orWhereArrayOverlapsTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, values: ArgsType, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereArrayMethods<ObjectLiteral> {
@@ -67,3 +67,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereArrayMethods<Entity> {
+    }
+}

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-array.extension");
 const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 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");
@@ -27,6 +28,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

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

@@ -14,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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    whereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    andWhereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(where: (proxy: DeepUnwrapArray<Type>) => ProxyColumnValueType, value: string | null | undefined, options?: TypedILikeOptions): this;
+    orWhereILikeTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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
@@ -33,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 = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    whereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    andWhereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(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 = TypedRoot<Entity>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
+    orWhereSearchTyped<Type extends ObjectLiteral = TypedRoot<Entity, this>>(selectors: ReadonlyArray<SearchSelector<Type>>, value: string | null | undefined, options?: TypedSearchOptions): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereILikeMethods<ObjectLiteral> {
@@ -61,3 +61,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereILikeMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereILikeMethods<Entity> {
+    }
+}

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 const sql_utils_1 = require("../../../utils/sql.utils");
@@ -46,6 +47,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);

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

@@ -11,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, TypedRoot<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, this>>>) => 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, TypedRoot<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, this>>>) => 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, TypedRoot<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, this>>>) => 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, TypedRoot<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, this>>>) => 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, TypedRoot<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, this>>>) => 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, TypedRoot<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, this>>>) => Value, array?: TypedArrayArg<Type, Value>, arrayType?: string): this;
 }
 declare module 'typeorm/query-builder/WhereExpressionBuilder' {
     interface WhereExpressionBuilder extends TypedWhereIsAnyMethods<ObjectLiteral> {
@@ -52,3 +52,7 @@ declare module 'typeorm/query-builder/DeleteQueryBuilder' {
     interface DeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
     }
 }
+declare module 'typeorm/query-builder/SoftDeleteQueryBuilder' {
+    interface SoftDeleteQueryBuilder<Entity extends ObjectLiteral> extends TypedWhereIsAnyMethods<Entity> {
+    }
+}

package/dist/extensions/typed/typed-where/typed-where-is-any.extension.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 require("../../where-is-any.extension");
 const typeorm_1 = require("typeorm");
+const SoftDeleteQueryBuilder_1 = require("typeorm/query-builder/SoftDeleteQueryBuilder");
 const query_builder_utils_1 = require("../../../utils/query-builder.utils");
 const prototype_utils_1 = require("../../../utils/prototype.utils");
 /* eslint-enable @typescript-eslint/no-empty-interface */
@@ -23,6 +24,7 @@ const queryBuilders = [
     typeorm_1.SelectQueryBuilder,
     typeorm_1.UpdateQueryBuilder,
     typeorm_1.DeleteQueryBuilder,
+    SoftDeleteQueryBuilder_1.SoftDeleteQueryBuilder,
 ];
 queryBuilders.forEach((builder) => {
     (0, prototype_utils_1.patchPrototype)(builder, extension);