@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.300

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, QBFilterQuery, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate } from '../typings.js';
+import type { ConnectionType, Constructor, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName, PopulateHintOptions, Prefixes } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -7,34 +7,40 @@ import type { Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { DriverException } from '../exceptions.js';
 import type { Configuration } from '../utils/Configuration.js';
+import type { MikroORM } from '../MikroORM.js';
 import type { LoggingOptions, LogContext } from '../logging/Logger.js';
-import type { RawQueryFragment } from '../utils/RawQueryFragment.js';
+import type { Raw } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
 export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
-    connect(): Promise<C>;
+    connect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     close(force?: boolean): Promise<void>;
-    reconnect(): Promise<C>;
+    reconnect(options?: {
+        skipOnConnect?: boolean;
+    }): Promise<C>;
     getConnection(type?: ConnectionType): C;
     /**
      * Finds selection of entities
      */
-    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
+    find<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOptions<T, P, F, E>): Promise<EntityData<T>[]>;
     /**
      * Finds single entity (table row, document)
      */
-    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: string, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
-    findVirtual<T extends object>(entityName: string, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
-    nativeInsert<T extends object>(entityName: string, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeInsertMany<T extends object>(entityName: string, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
-    nativeUpdate<T extends object>(entityName: string, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
-    nativeUpdateMany<T extends object>(entityName: string, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
-    nativeDelete<T extends object>(entityName: string, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
+    findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
+    nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
-    count<T extends object, P extends string = never>(entityName: string, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
-    aggregate(entityName: string, pipeline: any[]): Promise<any[]>;
+    count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
     mapResult<T extends object>(result: EntityDictionary<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
     /**
      * When driver uses pivot tables for M:N, this method will load identifiers for given collections from them
@@ -60,6 +66,10 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
         schema?: string;
         parentSchema?: string;
     }): string | undefined;
+    /**
+     * @internal
+     */
+    getORMClass(): Constructor<MikroORM>;
 }
 export type EntityField<T, P extends string = PopulatePath.ALL> = keyof T | PopulatePath.ALL | AutoPath<T, P, `${PopulatePath.ALL}`>;
 export type OrderDefinition<T> = (QueryOrderMap<T> & {
@@ -68,6 +78,18 @@ export type OrderDefinition<T> = (QueryOrderMap<T> & {
 export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
+export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
+    /**
+     * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
+     * You can opt out of this behavior by specifying `mergeResults: false`. This will yield every row from
+     * the SQL result, but still mapped to entities, meaning that to-many collections will contain at most
+     * a single item, and you will get duplicate root entities when they have multiple items in the populated
+     * collection.
+     *
+     * @default true
+     */
+    mergeResults?: boolean;
+}
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
 export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
@@ -88,8 +110,28 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
      * when nesting the condition. This is used for implementation of joined filters.
      */
     populateFilter?: ObjectQuery<Entity>;
+    /**
+     * Index-friendly alternative to `$or` for conditions that span joined relations.
+     * Each array element becomes an independent branch combined via `UNION ALL` subquery:
+     * `WHERE pk IN (branch_1 UNION ALL branch_2 ... branch_N)`.
+     * The database plans each branch independently, enabling per-table index usage
+     * (e.g. GIN trigram indexes for fuzzy search across related entities).
+     * sql only
+     */
+    unionWhere?: ObjectQuery<Entity>[];
+    /**
+     * Strategy for combining `unionWhere` branches.
+     * - `'union-all'` (default) — skips deduplication, faster for most use cases.
+     * - `'union'` — deduplicates rows between branches; useful when branch overlap is very high.
+     * sql only
+     */
+    unionWhereStrategy?: 'union-all' | 'union';
     /** Used for ordering of the populate queries. If not specified, the value of `options.orderBy` is used. */
     populateOrderBy?: OrderDefinition<Entity>;
+    /** Per-relation overrides for populate loading behavior. Keys are populate paths (same as used in `populate`). */
+    populateHints?: [Hint] extends [never] ? never : {
+        [K in Prefixes<Hint>]?: PopulateHintOptions;
+    };
     /** Ordering of the results.Can be an object or array of objects, keys are property names, values are ordering (asc/desc) */
     orderBy?: OrderDefinition<Entity>;
     /** Control result caching for this query. Result cache is by default disabled, not to be confused with the identity map. */
@@ -127,7 +169,7 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     flags?: QueryFlag[];
     /** sql only */
     groupBy?: string | string[];
-    having?: QBFilterQuery<Entity>;
+    having?: FilterQuery<Entity>;
     /** sql only */
     strategy?: LoadStrategy | `${LoadStrategy}`;
     flushMode?: FlushMode | `${FlushMode}`;
@@ -138,18 +180,27 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     lockTableAliases?: string[];
     ctx?: Transaction;
     connectionType?: ConnectionType;
-    /** sql only */
-    indexHint?: string;
+    /** SQL: appended to FROM clause (e.g. `'force index(my_index)'`); MongoDB: index name or spec passed as `hint`. */
+    indexHint?: string | Dictionary;
     /** sql only */
     comments?: string | string[];
     /** sql only */
     hintComments?: string | string[];
+    /** SQL: collation name string applied as COLLATE to ORDER BY; MongoDB: CollationOptions object. */
+    collation?: CollationOptions | string;
+    /** mongodb only */
+    maxTimeMS?: number;
+    /** mongodb only */
+    allowDiskUse?: boolean;
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
-export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'offset'> {
+export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindAllOptions<T, P, F, E>, 'limit' | 'offset'> {
+    includeCount?: I;
 }
-export interface FindOneOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
+export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }
@@ -163,15 +214,24 @@ export interface NativeInsertUpdateOptions<T> {
     schema?: string;
     /** `nativeUpdate()` only option */
     upsert?: boolean;
+    loggerContext?: LogContext;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
+    filters?: FilterOptions;
+    /** @internal */
+    em?: EntityManager;
 }
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
 }
 export interface UpsertOptions<Entity, Fields extends string = never> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
-    onConflictFields?: (keyof Entity)[] | RawQueryFragment;
+    onConflictFields?: (keyof Entity)[] | Raw;
     onConflictAction?: 'ignore' | 'merge';
     onConflictMergeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     onConflictExcludeFields?: AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
+    onConflictWhere?: FilterQuery<Entity>;
     disableIdentityMap?: boolean;
 }
 export interface UpsertManyOptions<Entity, Fields extends string = never> extends UpsertOptions<Entity, Fields> {
@@ -181,33 +241,59 @@ export interface CountOptions<T extends object, P extends string = never> {
     filters?: FilterOptions;
     schema?: string;
     groupBy?: string | readonly string[];
-    having?: QBFilterQuery<T>;
+    having?: FilterQuery<T>;
     cache?: boolean | number | [string, number];
     populate?: Populate<T, P>;
     populateWhere?: ObjectQuery<T> | PopulateHint | `${PopulateHint}`;
     populateFilter?: ObjectQuery<T>;
+    /** @see FindOptions.unionWhere */
+    unionWhere?: ObjectQuery<T>[];
+    /** @see FindOptions.unionWhereStrategy */
+    unionWhereStrategy?: 'union-all' | 'union';
     ctx?: Transaction;
     connectionType?: ConnectionType;
     flushMode?: FlushMode | `${FlushMode}`;
-    /** sql only */
-    indexHint?: string;
+    /** SQL: appended to FROM clause (e.g. `'force index(my_index)'`); MongoDB: index name or spec passed as `hint`. */
+    indexHint?: string | Dictionary;
     /** sql only */
     comments?: string | string[];
     /** sql only */
     hintComments?: string | string[];
+    /** SQL: collation name string applied as COLLATE; MongoDB: CollationOptions object. */
+    collation?: CollationOptions | string;
+    /** mongodb only */
+    maxTimeMS?: number;
     loggerContext?: LogContext;
     logging?: LoggingOptions;
+    /** @internal used to apply filters to the auto-joined relations */
+    em?: EntityManager;
 }
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
     schema?: string;
     ctx?: Transaction;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
 }
 export interface DeleteOptions<T> extends DriverMethodOptions {
     filters?: FilterOptions;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
+    /** @internal */
+    em?: EntityManager;
 }
 export interface NativeDeleteOptions<T> extends DriverMethodOptions {
     filters?: FilterOptions;
+    /** sql only */
+    unionWhere?: ObjectQuery<T>[];
+    /** sql only */
+    unionWhereStrategy?: 'union-all' | 'union';
+    /** @internal */
+    em?: EntityManager;
 }
 export interface LockOptions extends DriverMethodOptions {
     lockMode?: LockMode;
@@ -218,9 +304,25 @@ export interface LockOptions extends DriverMethodOptions {
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
+    loggerContext?: LogContext;
+}
+export interface CollationOptions {
+    locale: string;
+    caseLevel?: boolean;
+    caseFirst?: string;
+    strength?: number;
+    numericOrdering?: boolean;
+    alternate?: string;
+    maxVariable?: string;
+    backwards?: boolean;
 }
 export interface GetReferenceOptions {
     wrapped?: boolean;
     convertCustomTypes?: boolean;
     schema?: string;
+    /**
+     * Property name to use for identity map lookup instead of the primary key.
+     * This is useful for creating references by unique non-PK properties.
+     */
+    key?: string;
 }

package/entity/BaseEntity.d.ts

@@ -1,20 +1,79 @@
 import { type Ref } from './Reference.js';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected, SerializeDTO } from '../typings.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions } from '../drivers/IDatabaseDriver.js';
+import type { PopulatePath } from '../enums.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
-    isTouched(): boolean;
     populated(populated?: boolean): void;
-    populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
+    /**
+     * Converts the entity to a plain object representation.
+     *
+     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+     *
+     * For correct typing that reflects loaded relations, use `wrap()`:
+     * ```ts
+     * const result = await em.find(User, {}, { populate: ['profile'] });
+     * // Type: EntityDTO<User> (profile is number)
+     * const obj1 = result[0].toObject();
+     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+     * const obj2 = wrap(result[0]).toObject();
+     * ```
+     *
+     * Runtime values are correct in both cases - only the static types differ.
+     */
     toObject<Entity extends this = this>(): EntityDTO<Entity>;
+    /**
+     * Converts the entity to a plain object representation.
+     *
+     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+     *
+     * For correct typing that reflects loaded relations, use `wrap()`:
+     * ```ts
+     * const result = await em.find(User, {}, { populate: ['profile'] });
+     * // Type: EntityDTO<User> (profile is number)
+     * const obj1 = result[0].toObject();
+     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+     * const obj2 = wrap(result[0]).toObject();
+     * ```
+     *
+     * Runtime values are correct in both cases - only the static types differ.
+     */
     toObject<Entity extends this = this>(ignoreFields: never[]): EntityDTO<Entity>;
+    /**
+     * Converts the entity to a plain object representation.
+     *
+     * **Note on typing with `Loaded` entities:** When called on a `Loaded<Entity, 'relation'>` type,
+     * the return type will be `EntityDTO<Entity>` (with relations as primary keys), not
+     * `EntityDTO<Loaded<Entity, 'relation'>>` (with loaded relations as nested objects).
+     * This is a TypeScript limitation - the `this` type resolves to the class, not the `Loaded` wrapper.
+     *
+     * For correct typing that reflects loaded relations, use `wrap()`:
+     * ```ts
+     * const result = await em.find(User, {}, { populate: ['profile'] });
+     * // Type: EntityDTO<User> (profile is number)
+     * const obj1 = result[0].toObject();
+     * // Type: EntityDTO<Loaded<User, 'profile'>> (profile is nested object)
+     * const obj2 = wrap(result[0]).toObject();
+     * ```
+     *
+     * Runtime values are correct in both cases - only the static types differ.
+     *
+     * @param ignoreFields - Array of field names to omit from the result.
+     */
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
-    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
+    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
     assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Entity extends this = this, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     getSchema(): string | undefined;

package/entity/BaseEntity.js

@@ -6,9 +6,6 @@ export class BaseEntity {
     isInitialized() {
         return helper(this).__initialized;
     }
-    isTouched() {
-        return helper(this).__touched;
-    }
     populated(populated = true) {
         helper(this).populated(populated);
     }

package/entity/Collection.d.ts

@@ -1,19 +1,25 @@
-import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Populate } from '../typings.js';
-import { ArrayCollection } from './ArrayCollection.js';
+import type { EntityDTO, EntityKey, EntityProperty, FilterQuery, IPrimaryKey, Loaded, LoadedCollection, Populate, Primary } from '../typings.js';
 import { Reference } from './Reference.js';
 import type { Transaction } from '../connections/Connection.js';
-import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver.js';
+import type { CountOptions, FindOptions } from '../drivers/IDatabaseDriver.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 export interface MatchingOptions<T extends object, P extends string = never> extends FindOptions<T, P> {
     where?: FilterQuery<T>;
     store?: boolean;
     ctx?: Transaction;
 }
-export declare class Collection<T extends object, O extends object = object> extends ArrayCollection<T, O> {
+export declare class Collection<T extends object, O extends object = object> {
+    readonly owner: O;
+    [k: number]: T;
+    protected readonly items: Set<T>;
+    protected initialized: boolean;
+    protected dirty: boolean;
+    protected partial: boolean;
+    protected snapshot: T[] | undefined;
     private readonly?;
+    protected _count?: number;
+    private _property?;
     private _populated?;
-    private _em?;
-    private _snapshot?;
     constructor(owner: O, items?: T[], initialized?: boolean);
     /**
      * Creates new Collection instance, assigns it to the owning entity and sets the items to it (propagating them to their inverse sides)
@@ -40,59 +46,124 @@ export declare class Collection<T extends object, O extends object = object> ext
      */
     getItems(check?: boolean): T[];
     toJSON<TT extends T>(): EntityDTO<TT>[];
-    add<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): void;
+    add<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>>, ...entities: (TT | Reference<TT>)[]): number;
     /**
-     * @inheritDoc
+     * Remove specified item(s) from the collection. Note that removing item from collection does not necessarily imply deleting the target entity,
+     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
+     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
+     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
      */
-    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): void;
+    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): number;
     contains<TT extends T>(item: TT | Reference<TT>, check?: boolean): boolean;
     count(): number;
     isEmpty(): boolean;
+    shouldPopulate(populated?: boolean): boolean;
+    populated(populated?: boolean | undefined): void;
+    init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
+    private getEntityManager;
+    private createCondition;
+    private createManyToManyCondition;
+    private createLoadCountCondition;
+    private checkInitialized;
     /**
-     * @inheritDoc
+     * re-orders items after searching with `$in` operator
+     */
+    private reorderItems;
+    private cancelOrphanRemoval;
+    private validateModification;
+    toArray<TT extends T>(): EntityDTO<TT>[];
+    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string | string[]): U[];
+    /**
+     * @internal
+     */
+    addWithoutPropagation(entity: T): void;
+    set(items: Iterable<T | Reference<T>>): void;
+    private compare;
+    /**
+     * @internal
+     */
+    hydrate(items: T[], forcePropagate?: boolean, partial?: boolean): void;
+    /**
+     * Remove all items from the collection. Note that removing items from collection does not necessarily imply deleting the target entity,
+     * it means we are disconnecting the relation - removing items from collection, not removing entities from database - `Collection.remove()`
+     * is not the same as `em.remove()`. If we want to delete the entity by removing it from collection, we need to enable `orphanRemoval: true`,
+     * which tells the ORM we don't want orphaned entities to exist, so we know those should be removed.
+     */
+    removeAll(): void;
+    /**
+     * @internal
+     */
+    removeWithoutPropagation(entity: T): void;
+    /**
+     * Extracts a slice of the collection items starting at position start to end (exclusive) of the collection.
+     * If end is null it returns all elements from start to the end of the collection.
      */
     slice(start?: number, end?: number): T[];
     /**
-     * @inheritDoc
+     * Tests for the existence of an element that satisfies the given predicate.
      */
     exists(cb: (item: T) => boolean): boolean;
     /**
-     * @inheritDoc
+     * Returns the first element of this collection that satisfies the predicate.
+     */
+    find<S extends T>(cb: (item: T, index: number) => item is S): S | undefined;
+    /**
+     * Returns the first element of this collection that satisfies the predicate.
      */
     find(cb: (item: T, index: number) => boolean): T | undefined;
     /**
-     * @inheritDoc
+     * Extracts a subset of the collection items.
+     */
+    filter<S extends T>(cb: (item: T, index: number) => item is S): S[];
+    /**
+     * Extracts a subset of the collection items.
      */
     filter(cb: (item: T, index: number) => boolean): T[];
     /**
-     * @inheritDoc
+     * Maps the collection items based on your provided mapper function.
      */
     map<R>(mapper: (item: T, index: number) => R): R[];
     /**
-     * @inheritDoc
+     * Maps the collection items based on your provided mapper function to a single object.
+     */
+    reduce<R>(cb: (obj: R, item: T, index: number) => R, initial?: R): R;
+    /**
+     * Maps the collection items to a dictionary, indexed by the key you specify.
+     * If there are more items with the same key, only the first one will be present.
      */
     indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1): Record<T[K1] & PropertyKey, T>;
     /**
-     * @inheritDoc
+     * Maps the collection items to a dictionary, indexed by the key you specify.
+     * If there are more items with the same key, only the first one will be present.
      */
     indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1, valueKey: K2): Record<T[K1] & PropertyKey, T[K2]>;
-    shouldPopulate(populated?: boolean): boolean;
-    populated(populated?: boolean | undefined): void;
-    init<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
-    private getEntityManager;
-    private createCondition;
-    private createOrderBy;
-    private createManyToManyCondition;
-    private createLoadCountCondition;
-    private modify;
-    private checkInitialized;
+    isInitialized(fully?: boolean): boolean;
+    isDirty(): boolean;
+    isPartial(): boolean;
+    setDirty(dirty?: boolean): void;
+    get length(): number;
+    [Symbol.iterator](): IterableIterator<T>;
     /**
-     * re-orders items after searching with `$in` operator
+     * @internal
      */
-    private reorderItems;
-    private cancelOrphanRemoval;
-    private validateItemType;
-    private validateModification;
+    takeSnapshot(forcePropagate?: boolean): void;
+    /**
+     * @internal
+     */
+    getSnapshot(): T[] | undefined;
+    /**
+     * @internal
+     */
+    get property(): EntityProperty;
+    /**
+     * @internal
+     */
+    set property(prop: EntityProperty);
+    protected propagate(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
+    protected propagateToInverseSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
+    protected propagateToOwningSide(item: T, method: 'add' | 'remove' | 'takeSnapshot'): void;
+    protected shouldPropagateToCollection(collection: Collection<O, T>, method: 'add' | 'remove' | 'takeSnapshot'): boolean;
+    protected incrementCount(value: number): void;
 }
 export interface InitCollectionOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends EntityLoaderOptions<T, F, E> {
     dataloader?: boolean;