@yandjin-mikro-orm/core 6.1.4-rc-sti-changes-1

package/entity/ArrayCollection.d.ts

@@ -0,0 +1,113 @@
+/// <reference types="node" />
+import { inspect } from 'util';
+import type { EntityDTO, EntityProperty, IPrimaryKey, Primary } from '../typings';
+import { Reference } from './Reference';
+export declare class ArrayCollection<T extends object, O extends object> {
+    readonly owner: O;
+    protected readonly items: Set<T>;
+    protected initialized: boolean;
+    protected dirty: boolean;
+    protected snapshot: T[] | undefined;
+    protected _count?: number;
+    private _property?;
+    constructor(owner: O, items?: T[]);
+    loadCount(): Promise<number>;
+    getItems(): T[];
+    toArray<TT extends T>(): EntityDTO<TT>[];
+    toJSON(): EntityDTO<T>[];
+    getIdentifiers<U extends IPrimaryKey = Primary<T> & IPrimaryKey>(field?: string): U[];
+    add(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): void;
+    set(items: Iterable<T | Reference<T>>): void;
+    private compare;
+    /**
+     * @internal
+     */
+    hydrate(items: T[], forcePropagate?: boolean): void;
+    /**
+     * 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(entity: T | Reference<T> | Iterable<T | Reference<T>>, ...entities: (T | Reference<T>)[]): 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;
+    contains(item: T | Reference<T>, check?: boolean): boolean;
+    /**
+     * 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[];
+    /**
+     * Tests for the existence of an element that satisfies the given predicate.
+     */
+    exists(cb: (item: T) => boolean): boolean;
+    /**
+     * Returns the first element of this collection that satisfies the predicate.
+     */
+    find(cb: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * Extracts a subset of the collection items.
+     */
+    filter(cb: (item: T, index: number) => boolean): T[];
+    /**
+     * Maps the collection items based on your provided mapper function.
+     */
+    map<R>(mapper: (item: T, index: number) => R): R[];
+    /**
+     * 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>;
+    /**
+     * 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]>;
+    count(): number;
+    isInitialized(fully?: boolean): boolean;
+    isDirty(): boolean;
+    isEmpty(): boolean;
+    setDirty(dirty?: boolean): void;
+    get length(): number;
+    [Symbol.iterator](): IterableIterator<T>;
+    /**
+     * @internal
+     */
+    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: ArrayCollection<O, T>, method: 'add' | 'remove' | 'takeSnapshot'): boolean;
+    protected incrementCount(value: number): void;
+    /** @ignore */
+    [inspect.custom](depth: number): string;
+}
+export interface ArrayCollection<T, O> {
+    [k: number]: T;
+}

package/entity/ArrayCollection.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayCollection = void 0;
+const util_1 = require("util");
+const Reference_1 = require("./Reference");
+const wrap_1 = require("./wrap");
+const errors_1 = require("../errors");
+const enums_1 = require("../enums");
+const Utils_1 = require("../utils/Utils");
+class ArrayCollection {
+    owner;
+    items = new Set();
+    initialized = true;
+    dirty = false;
+    snapshot = []; // used to create a diff of the collection at commit time, undefined marks overridden values so we need to wipe when flushing
+    _count;
+    _property;
+    constructor(owner, items) {
+        this.owner = owner;
+        /* istanbul ignore next */
+        if (items) {
+            let i = 0;
+            this.items = new Set(items);
+            this.items.forEach(item => this[i++] = item);
+        }
+    }
+    async loadCount() {
+        return this.items.size;
+    }
+    getItems() {
+        return [...this.items];
+    }
+    toArray() {
+        if (this.items.size === 0) {
+            return [];
+        }
+        const meta = this.property.targetMeta;
+        const args = [...meta.toJsonParams.map(() => undefined)];
+        return this.map(item => (0, wrap_1.wrap)(item).toJSON(...args));
+    }
+    toJSON() {
+        return this.toArray();
+    }
+    getIdentifiers(field) {
+        const items = this.getItems();
+        if (items.length === 0) {
+            return [];
+        }
+        field ??= this.property.targetMeta.serializedPrimaryKey;
+        return items.map(i => {
+            if (Utils_1.Utils.isEntity(i[field], true)) {
+                return (0, wrap_1.wrap)(i[field], true).getPrimaryKey();
+            }
+            return i[field];
+        });
+    }
+    add(entity, ...entities) {
+        entities = Utils_1.Utils.asArray(entity).concat(entities);
+        for (const item of entities) {
+            const entity = Reference_1.Reference.unwrapReference(item);
+            if (!this.contains(entity, false)) {
+                this.incrementCount(1);
+                this[this.items.size] = entity;
+                this.items.add(entity);
+                this.propagate(entity, 'add');
+            }
+        }
+    }
+    set(items) {
+        if (!this.initialized) {
+            this.initialized = true;
+            this.snapshot = undefined;
+        }
+        if (this.compare(Utils_1.Utils.asArray(items).map(item => Reference_1.Reference.unwrapReference(item)))) {
+            return;
+        }
+        this.remove(this.items);
+        this.add(items);
+    }
+    compare(items) {
+        if (items.length !== this.items.size) {
+            return false;
+        }
+        let idx = 0;
+        for (const item of this.items) {
+            if (item !== items[idx++]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * @internal
+     */
+    hydrate(items, forcePropagate) {
+        for (let i = 0; i < this.items.size; i++) {
+            delete this[i];
+        }
+        this.initialized = true;
+        this.items.clear();
+        this._count = 0;
+        this.add(items);
+        this.takeSnapshot(forcePropagate);
+    }
+    /**
+     * 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(entity, ...entities) {
+        entities = Utils_1.Utils.asArray(entity).concat(entities);
+        let modified = false;
+        for (const item of entities) {
+            if (!item) {
+                continue;
+            }
+            const entity = Reference_1.Reference.unwrapReference(item);
+            if (this.items.delete(entity)) {
+                this.incrementCount(-1);
+                delete this[this.items.size]; // remove last item
+                this.propagate(entity, 'remove');
+                modified = true;
+            }
+        }
+        if (modified) {
+            Object.assign(this, [...this.items]); // reassign array access
+        }
+    }
+    /**
+     * 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() {
+        if (!this.initialized) {
+            this.initialized = true;
+            this.snapshot = undefined;
+        }
+        this.remove(this.items);
+    }
+    /**
+     * @internal
+     */
+    removeWithoutPropagation(entity) {
+        if (!this.items.delete(entity)) {
+            return;
+        }
+        this.incrementCount(-1);
+        delete this[this.items.size];
+        Object.assign(this, [...this.items]);
+    }
+    contains(item, check) {
+        const entity = Reference_1.Reference.unwrapReference(item);
+        return this.items.has(entity);
+    }
+    /**
+     * 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 = 0, end) {
+        let index = 0;
+        end ??= this.items.size;
+        const items = [];
+        for (const item of this.items) {
+            if (index === end) {
+                break;
+            }
+            if (index >= start && index < end) {
+                items.push(item);
+            }
+            index++;
+        }
+        return items;
+    }
+    /**
+     * Tests for the existence of an element that satisfies the given predicate.
+     */
+    exists(cb) {
+        for (const item of this.items) {
+            if (cb(item)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Returns the first element of this collection that satisfies the predicate.
+     */
+    find(cb) {
+        let index = 0;
+        for (const item of this.items) {
+            if (cb(item, index++)) {
+                return item;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extracts a subset of the collection items.
+     */
+    filter(cb) {
+        const items = [];
+        let index = 0;
+        for (const item of this.items) {
+            if (cb(item, index++)) {
+                items.push(item);
+            }
+        }
+        return items;
+    }
+    /**
+     * Maps the collection items based on your provided mapper function.
+     */
+    map(mapper) {
+        const items = [];
+        let index = 0;
+        for (const item of this.items) {
+            items.push(mapper(item, index++));
+        }
+        return items;
+    }
+    /**
+     * Maps the collection items based on your provided mapper function to a single object.
+     */
+    reduce(cb, initial = {}) {
+        let index = 0;
+        for (const item of this.items) {
+            initial = cb(initial, item, index++);
+        }
+        return initial;
+    }
+    /**
+     * 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(key, valueKey) {
+        return this.reduce((obj, item) => {
+            obj[item[key]] ??= valueKey ? item[valueKey] : item;
+            return obj;
+        }, {});
+    }
+    count() {
+        return this.items.size;
+    }
+    isInitialized(fully = false) {
+        if (!this.initialized || !fully) {
+            return this.initialized;
+        }
+        for (const item of this.items) {
+            if (!(0, wrap_1.helper)(item).__initialized) {
+                return false;
+            }
+        }
+        return true;
+    }
+    isDirty() {
+        return this.dirty;
+    }
+    isEmpty() {
+        return this.count() === 0;
+    }
+    setDirty(dirty = true) {
+        this.dirty = dirty;
+    }
+    get length() {
+        return this.count();
+    }
+    *[Symbol.iterator]() {
+        for (const item of this.getItems()) {
+            yield item;
+        }
+    }
+    /**
+     * @internal
+     */
+    takeSnapshot(forcePropagate) {
+        this.snapshot = [...this.items];
+        this.setDirty(false);
+        if (this.property.owner || forcePropagate) {
+            this.items.forEach(item => {
+                this.propagate(item, 'takeSnapshot');
+            });
+        }
+    }
+    /**
+     * @internal
+     */
+    getSnapshot() {
+        return this.snapshot;
+    }
+    /**
+     * @internal
+     */
+    get property() {
+        if (!this._property) {
+            const meta = (0, wrap_1.helper)(this.owner).__meta;
+            /* istanbul ignore if */
+            if (!meta) {
+                throw errors_1.MetadataError.fromUnknownEntity(this.owner.constructor.name, 'Collection.property getter, maybe you just forgot to initialize the ORM?');
+            }
+            this._property = meta.relations.find(prop => this.owner[prop.name] === this);
+        }
+        return this._property;
+    }
+    /**
+     * @internal
+     */
+    set property(prop) {
+        this._property = prop;
+    }
+    propagate(item, method) {
+        if (this.property.owner && this.property.inversedBy) {
+            this.propagateToInverseSide(item, method);
+        }
+        else if (!this.property.owner && this.property.mappedBy) {
+            this.propagateToOwningSide(item, method);
+        }
+    }
+    propagateToInverseSide(item, method) {
+        const collection = item[this.property.inversedBy];
+        if (this.shouldPropagateToCollection(collection, method)) {
+            collection[method](this.owner);
+        }
+    }
+    propagateToOwningSide(item, method) {
+        const mappedBy = this.property.mappedBy;
+        const collection = item[mappedBy];
+        if (this.property.kind === enums_1.ReferenceKind.MANY_TO_MANY) {
+            if (this.shouldPropagateToCollection(collection, method)) {
+                collection[method](this.owner);
+            }
+        }
+        else if (this.property.kind === enums_1.ReferenceKind.ONE_TO_MANY && method !== 'takeSnapshot') {
+            const prop2 = this.property.targetMeta.properties[mappedBy];
+            const owner = prop2.mapToPk ? (0, wrap_1.helper)(this.owner).getPrimaryKey() : this.owner;
+            const value = method === 'add' ? owner : null;
+            if (this.property.orphanRemoval && method === 'remove') {
+                // cache the PK before we propagate, as its value might be needed when flushing
+                (0, wrap_1.helper)(item).__pk = (0, wrap_1.helper)(item).getPrimaryKey();
+            }
+            if (!prop2.nullable && prop2.deleteRule !== 'cascade' && method === 'remove') {
+                if (!this.property.orphanRemoval) {
+                    throw errors_1.ValidationError.cannotRemoveFromCollectionWithoutOrphanRemoval(this.owner, this.property);
+                }
+                return;
+            }
+            // skip if already propagated
+            if (Reference_1.Reference.unwrapReference(item[mappedBy]) !== value) {
+                item[mappedBy] = value;
+            }
+        }
+    }
+    shouldPropagateToCollection(collection, method) {
+        if (!collection) {
+            return false;
+        }
+        switch (method) {
+            case 'add':
+                return !collection.contains(this.owner, false);
+            case 'remove':
+                return collection.isInitialized() && collection.contains(this.owner, false);
+            case 'takeSnapshot':
+                return collection.isDirty();
+        }
+    }
+    incrementCount(value) {
+        if (typeof this._count === 'number' && this.initialized) {
+            this._count += value;
+        }
+    }
+    /** @ignore */
+    [util_1.inspect.custom](depth) {
+        const object = { ...this };
+        const hidden = ['items', 'owner', '_property', '_count', 'snapshot', '_populated', '_snapshot', '_lazyInitialized', '_em', 'readonly'];
+        hidden.forEach(k => delete object[k]);
+        const ret = (0, util_1.inspect)(object, { depth });
+        const name = `${this.constructor.name}<${this.property?.type ?? 'unknown'}>`;
+        return ret === '[Object]' ? `[${name}]` : name + ' ' + ret;
+    }
+}
+exports.ArrayCollection = ArrayCollection;
+Object.defineProperties(ArrayCollection.prototype, {
+    __collection: { value: true, enumerable: false, writable: false },
+});

package/entity/BaseEntity.d.ts

@@ -0,0 +1,22 @@
+import { type Ref } from './Reference';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings';
+import { type AssignOptions } from './EntityAssigner';
+import type { EntityLoaderOptions } from './EntityLoader';
+import { type SerializeOptions } from '../serialization/EntitySerializer';
+import type { FindOneOptions } from '../drivers/IDatabaseDriver';
+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>>;
+    toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
+    toObject<Entity extends this = this>(): EntityDTO<Entity>;
+    toObject<Entity extends this = this>(ignoreFields: never[]): EntityDTO<Entity>;
+    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, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Data extends EntityData<Naked> | Partial<EntityDTO<Naked>> = EntityData<Naked> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions): 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;
+    setSchema(schema?: string): void;
+}

package/entity/BaseEntity.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseEntity = void 0;
+const Reference_1 = require("./Reference");
+const EntityAssigner_1 = require("./EntityAssigner");
+const EntitySerializer_1 = require("../serialization/EntitySerializer");
+const wrap_1 = require("./wrap");
+class BaseEntity {
+    isInitialized() {
+        return (0, wrap_1.helper)(this).__initialized;
+    }
+    isTouched() {
+        return (0, wrap_1.helper)(this).__touched;
+    }
+    populated(populated = true) {
+        (0, wrap_1.helper)(this).populated(populated);
+    }
+    async populate(populate, options = {}) {
+        return (0, wrap_1.helper)(this).populate(populate, options);
+    }
+    toReference() {
+        return Reference_1.Reference.create(this);
+    }
+    toObject(ignoreFields) {
+        return (0, wrap_1.helper)(this).toObject(ignoreFields);
+    }
+    toPOJO() {
+        return (0, wrap_1.helper)(this).toPOJO();
+    }
+    serialize(options) {
+        return EntitySerializer_1.EntitySerializer.serialize(this, options);
+    }
+    assign(data, options = {}) {
+        return EntityAssigner_1.EntityAssigner.assign(this, data, options);
+    }
+    init(options) {
+        return (0, wrap_1.helper)(this).init(options);
+    }
+    getSchema() {
+        return (0, wrap_1.helper)(this).getSchema();
+    }
+    setSchema(schema) {
+        (0, wrap_1.helper)(this).setSchema(schema);
+    }
+}
+exports.BaseEntity = BaseEntity;
+Object.defineProperty(BaseEntity.prototype, '__baseEntity', { value: true, writable: false, enumerable: false });

package/entity/Collection.d.ts

@@ -0,0 +1,104 @@
+import type { EntityDTO, EntityKey, FilterQuery, Loaded, LoadedCollection, Populate } from '../typings';
+import { ArrayCollection } from './ArrayCollection';
+import { Reference } from './Reference';
+import type { Transaction } from '../connections/Connection';
+import type { FindOptions, CountOptions } from '../drivers/IDatabaseDriver';
+import type { EntityLoaderOptions } from './EntityLoader';
+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> {
+    private readonly?;
+    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)
+     */
+    static create<T extends object, O extends object = object>(owner: O, prop: EntityKey<O>, items: undefined | T[], initialized: boolean): Collection<T, O>;
+    /**
+     * Ensures the collection is loaded first (without reloading it if it already is loaded).
+     * Returns the Collection instance (itself), works the same as `Reference.load()`.
+     */
+    load<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<LoadedCollection<Loaded<TT, P>>>;
+    /**
+     * Initializes the collection and returns the items
+     */
+    loadItems<TT extends T, P extends string = never>(options?: InitCollectionOptions<TT, P>): Promise<Loaded<TT, P>[]>;
+    /**
+     * Gets the count of collection items from database instead of counting loaded items.
+     * The value is cached (unless you use the `where` option), use `refresh: true` to force reload it.
+     */
+    loadCount(options?: LoadCountOptions<T> | boolean): Promise<number>;
+    matching<TT extends T, P extends string = never>(options: MatchingOptions<T, P>): Promise<Loaded<TT, P>[]>;
+    /**
+     * Returns the items (the collection must be initialized)
+     */
+    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;
+    /**
+     * @inheritDoc
+     */
+    remove<TT extends T>(entity: TT | Reference<TT> | Iterable<TT | Reference<TT>> | ((item: TT) => boolean), ...entities: (TT | Reference<TT>)[]): void;
+    contains<TT extends T>(item: TT | Reference<TT>, check?: boolean): boolean;
+    count(): number;
+    isEmpty(): boolean;
+    /**
+     * @inheritDoc
+     */
+    slice(start?: number, end?: number): T[];
+    /**
+     * @inheritDoc
+     */
+    exists(cb: (item: T) => boolean): boolean;
+    /**
+     * @inheritDoc
+     */
+    find(cb: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * @inheritDoc
+     */
+    filter(cb: (item: T, index: number) => boolean): T[];
+    /**
+     * @inheritDoc
+     */
+    map<R>(mapper: (item: T, index: number) => R): R[];
+    /**
+     * @inheritDoc
+     */
+    indexBy<K1 extends keyof T, K2 extends keyof T = never>(key: K1): Record<T[K1] & PropertyKey, T>;
+    /**
+     * @inheritDoc
+     */
+    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;
+    /**
+     * re-orders items after searching with `$in` operator
+     */
+    private reorderItems;
+    private cancelOrphanRemoval;
+    private validateItemType;
+    private validateModification;
+}
+export interface InitCollectionOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends EntityLoaderOptions<T, F, E> {
+    dataloader?: boolean;
+    populate?: Populate<T, P>;
+    ref?: boolean;
+}
+export interface LoadCountOptions<T extends object> extends CountOptions<T, '*'> {
+    refresh?: boolean;
+    where?: FilterQuery<T>;
+}