@mikro-orm/core 7.0.4 → 7.0.5-dev.1

package/EntityManager.d.ts

@@ -6,52 +6,8 @@ import { type EntityRepository } from './entity/EntityRepository.js';
 import { EntityLoader, type EntityLoaderOptions } from './entity/EntityLoader.js';
 import { Reference } from './entity/Reference.js';
 import { UnitOfWork } from './unit-of-work/UnitOfWork.js';
-import type {
-  CountOptions,
-  DeleteOptions,
-  FilterOptions,
-  FindAllOptions,
-  FindByCursorOptions,
-  FindOneOptions,
-  FindOneOrFailOptions,
-  FindOptions,
-  GetReferenceOptions,
-  IDatabaseDriver,
-  LockOptions,
-  NativeInsertUpdateOptions,
-  StreamOptions,
-  UpdateOptions,
-  UpsertManyOptions,
-  UpsertOptions,
-} from './drivers/IDatabaseDriver.js';
-import type {
-  AnyString,
-  ArrayElement,
-  AutoPath,
-  ConnectionType,
-  Dictionary,
-  EntityClass,
-  EntityData,
-  EntityDictionary,
-  EntityDTO,
-  EntityMetadata,
-  EntityName,
-  FilterDef,
-  FilterQuery,
-  FromEntityType,
-  GetRepository,
-  IHydrator,
-  IsSubset,
-  Loaded,
-  MergeLoaded,
-  MergeSelected,
-  ObjectQuery,
-  PopulateOptions,
-  Primary,
-  Ref,
-  RequiredEntityData,
-  UnboxArray,
-} from './typings.js';
+import type { CountOptions, DeleteOptions, FilterOptions, FindAllOptions, FindByCursorOptions, FindOneOptions, FindOneOrFailOptions, FindOptions, GetReferenceOptions, IDatabaseDriver, LockOptions, NativeInsertUpdateOptions, StreamOptions, UpdateOptions, UpsertManyOptions, UpsertOptions } from './drivers/IDatabaseDriver.js';
+import type { AnyString, ArrayElement, AutoPath, ConnectionType, Dictionary, EntityClass, EntityData, EntityDictionary, EntityDTO, EntityMetadata, EntityName, FilterDef, FilterQuery, FromEntityType, GetRepository, IHydrator, IsSubset, Loaded, MergeLoaded, MergeSelected, ObjectQuery, PopulateOptions, Primary, Ref, RequiredEntityData, UnboxArray } from './typings.js';
 import { FlushMode, LockMode, PopulatePath, type TransactionOptions } from './enums.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { Transaction } from './connections/Connection.js';
@@ -63,850 +19,593 @@ import type { EntityComparator } from './utils/EntityComparator.js';
  * @template {IDatabaseDriver} Driver current driver type
  */
 export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDriver> {
-  #private;
-  readonly config: Configuration;
-  protected readonly driver: Driver;
-  protected readonly metadata: MetadataStorage;
-  protected readonly eventManager: EventManager;
-  /** @internal */
-  readonly '~entities'?: unknown;
-  /** @internal */
-  readonly _id: number;
-  /** Whether this is the global (root) EntityManager instance. */
-  readonly global = false;
-  /** The context name of this EntityManager, derived from the ORM configuration. */
-  readonly name: string;
-  protected loggerContext?: Dictionary;
-  /**
-   * @internal
-   */
-  constructor(
-    config: Configuration,
-    driver: Driver,
-    metadata: MetadataStorage,
-    useContext?: boolean,
-    eventManager?: EventManager,
-  );
-  /**
-   * Gets the Driver instance used by this EntityManager.
-   * Driver is singleton, for one MikroORM instance, only one driver is created.
-   */
-  getDriver(): Driver;
-  /**
-   * Gets the Connection instance, by default returns write connection
-   */
-  getConnection(type?: ConnectionType): ReturnType<Driver['getConnection']>;
-  /**
-   * Gets the platform instance. Just like the driver, platform is singleton, one for a MikroORM instance.
-   */
-  getPlatform(): ReturnType<Driver['getPlatform']>;
-  /**
-   * Gets repository for given entity. You can pass either string name or entity class reference.
-   */
-  getRepository<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(
-    entityName: EntityName<Entity>,
-  ): GetRepository<Entity, Repository>;
-  /**
-   * Shortcut for `em.getRepository()`.
-   */
-  repo<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(
-    entityName: EntityName<Entity>,
-  ): GetRepository<Entity, Repository>;
-  /**
-   * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
-   */
-  find<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<NoInfer<Entity>>,
-    options?: FindOptions<Entity, Hint, Fields, Excludes>,
-  ): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
-  /**
-   * Finds all entities and returns an async iterable (async generator) that yields results one by one.
-   * The results are merged and mapped to entity instances, without adding them to the identity map.
-   * You can disable merging by passing the options `{ mergeResults: false }`.
-   * With `mergeResults` disabled, to-many collections will contain at most one item, and you will get duplicate
-   * root entities when there are multiple items in the populated collection.
-   * This is useful for processing large datasets without loading everything into memory at once.
-   *
-   * ```ts
-   * const stream = em.stream(Book, { populate: ['author'] });
-   *
-   * for await (const book of stream) {
-   *   // book is an instance of Book entity
-   *   console.log(book.title, book.author.name);
-   * }
-   * ```
-   */
-  stream<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>,
-  ): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
-  /**
-   * Finds all entities of given type, optionally matching the `where` condition provided in the `options` parameter.
-   */
-  findAll<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    options?: FindAllOptions<NoInfer<Entity>, Hint, Fields, Excludes>,
-  ): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
-  private getPopulateWhere;
-  /**
-   * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
-   */
-  addFilter<T extends EntityName | readonly EntityName[]>(options: FilterDef<T>): void;
-  /**
-   * Sets filter parameter values globally inside context defined by this entity manager.
-   * If you want to set shared value for all contexts, be sure to use the root entity manager.
-   */
-  setFilterParams(name: string, args: Dictionary): void;
-  /**
-   * Returns filter parameters for given filter set in this context.
-   */
-  getFilterParams<T extends Dictionary = Dictionary>(name: string): T;
-  /**
-   * Sets logger context for this entity manager.
-   */
-  setLoggerContext(context: Dictionary): void;
-  /**
-   * Gets logger context for this entity manager.
-   */
-  getLoggerContext<T extends Dictionary = Dictionary>(options?: { disableContextResolution?: boolean }): T;
-  /** Sets the flush mode for this EntityManager. Pass `undefined` to reset to the global default. */
-  setFlushMode(flushMode?: FlushMode | `${FlushMode}`): void;
-  protected processWhere<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<Entity>,
-    options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>,
-    type: 'read' | 'update' | 'delete',
-  ): Promise<FilterQuery<Entity>>;
-  protected processUnionWhere<Entity extends object, Hint extends string = never>(
-    entityName: EntityName<Entity>,
-    options:
-      | FindOptions<Entity, Hint, any, any>
-      | CountOptions<Entity, Hint>
-      | UpdateOptions<Entity>
-      | DeleteOptions<Entity>,
-    type: 'read' | 'update' | 'delete',
-  ): Promise<void>;
-  protected applyDiscriminatorCondition<Entity extends object>(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<Entity>,
-  ): FilterQuery<Entity>;
-  protected createPopulateWhere<Entity extends object>(
-    cond: ObjectQuery<Entity>,
-    options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any> | CountOptions<Entity, any>,
-  ): ObjectQuery<Entity>;
-  protected getJoinedFilters<Entity extends object>(
-    meta: EntityMetadata<Entity>,
-    options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>,
-  ): Promise<ObjectQuery<Entity> | undefined>;
-  /**
-   * When filters are active on M:1 or 1:1 relations, we need to ref join them eagerly as they might affect the FK value.
-   */
-  protected autoJoinRefsForFilters<T extends object>(
-    meta: EntityMetadata<T>,
-    options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>,
-    parent?: {
-      class: EntityClass;
-      propName: string;
-    },
-  ): Promise<void>;
-  /**
-   * @internal
-   */
-  applyFilters<Entity extends object>(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<Entity> | undefined,
-    options: FilterOptions | undefined,
-    type: 'read' | 'update' | 'delete',
-    findOptions?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>,
-  ): Promise<FilterQuery<Entity> | undefined>;
-  /**
-   * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
-   * where the first element is the array of entities, and the second is the count.
-   */
-  findAndCount<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<NoInfer<Entity>>,
-    options?: FindOptions<Entity, Hint, Fields, Excludes>,
-  ): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
-  /**
-   * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as {@apilink Cursor} object.
-   * Supports `before`, `after`, `first` and `last` options while disallowing `limit` and `offset`. Explicit `orderBy` option
-   * is required.
-   *
-   * Use `first` and `after` for forward pagination, or `last` and `before` for backward pagination.
-   *
-   * - `first` and `last` are numbers and serve as an alternative to `offset`, those options are mutually exclusive, use only one at a time
-   * - `before` and `after` specify the previous cursor value, it can be one of the:
-   *     - `Cursor` instance
-   *     - opaque string provided by `startCursor/endCursor` properties
-   *     - POJO/entity instance
-   *
-   * ```ts
-   * const currentCursor = await em.findByCursor(User, {
-   *   first: 10,
-   *   after: previousCursor, // cursor instance
-   *   orderBy: { id: 'desc' },
-   * });
-   *
-   * // to fetch next page
-   * const nextCursor = await em.findByCursor(User, {
-   *   first: 10,
-   *   after: currentCursor.endCursor, // opaque string
-   *   orderBy: { id: 'desc' },
-   * });
-   *
-   * // to fetch next page
-   * const nextCursor2 = await em.findByCursor(User, {
-   *   first: 10,
-   *   after: { id: lastSeenId }, // entity-like POJO
-   *   orderBy: { id: 'desc' },
-   * });
-   * ```
-   *
-   * The options also support an `includeCount` (true by default) option. If set to false, the `totalCount` is not
-   * returned as part of the cursor. This is useful for performance reason, when you don't care about the total number
-   * of pages.
-   *
-   * The `Cursor` object provides the following interface:
-   *
-   * ```ts
-   * Cursor<User> {
-   *   items: [
-   *     User { ... },
-   *     User { ... },
-   *     User { ... },
-   *   ],
-   *   totalCount: 50, // not included if `includeCount: false`
-   *   startCursor: 'WzRd',
-   *   endCursor: 'WzZd',
-   *   hasPrevPage: true,
-   *   hasNextPage: true,
-   * }
-   * ```
-   */
-  findByCursor<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-    IncludeCount extends boolean = true,
-  >(
-    entityName: EntityName<Entity>,
-    options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>,
-  ): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
-  /**
-   * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
-   * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
-   * in database, the method throws an error just like `em.findOneOrFail()` (and respects the same config options).
-   */
-  refreshOrFail<
-    Entity extends object,
-    Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entity: Entity,
-    options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>,
-  ): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true>>;
-  /**
-   * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
-   * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
-   * in database, the method returns `null`.
-   */
-  refresh<
-    Entity extends object,
-    Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entity: Entity,
-    options?: FindOneOptions<Entity, Hint, Fields, Excludes>,
-  ): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true> | null>;
-  /**
-   * Finds first entity matching your `where` query.
-   */
-  findOne<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<NoInfer<Entity>>,
-    options?: FindOneOptions<Entity, Hint, Fields, Excludes>,
-  ): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
-  /**
-   * Finds first entity matching your `where` query. If nothing found, it will throw an error.
-   * If the `strict` option is specified and nothing is found or more than one matching entity is found, it will throw an error.
-   * You can override the factory for creating this method via `options.failHandler` locally
-   * or via `Configuration.findOneOrFailHandler` (`findExactlyOneOrFailHandler` when specifying `strict`) globally.
-   */
-  findOneOrFail<
-    Entity extends object,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<NoInfer<Entity>>,
-    options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>,
-  ): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
-  /**
-   * Creates or updates the entity, based on whether it is already present in the database.
-   * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
-   * entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
-   *
-   * ```ts
-   * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
-   * const author = await em.upsert(Author, { email: 'foo@bar.com', age: 33 });
-   * ```
-   *
-   * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
-   *
-   * ```ts
-   * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
-   * // select "id" from "author" where "email" = 'foo@bar.com'
-   * const author = await em.upsert(Author, { email: 'foo@bar.com', age: 33 });
-   * ```
-   *
-   * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
-   *
-   * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
-   */
-  upsert<Entity extends object, Fields extends string = any>(
-    entityNameOrEntity: EntityName<Entity> | Entity,
-    data?: EntityData<Entity> | NoInfer<Entity>,
-    options?: UpsertOptions<Entity, Fields>,
-  ): Promise<Entity>;
-  /**
-   * Creates or updates the entity, based on whether it is already present in the database.
-   * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
-   * entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
-   *
-   * ```ts
-   * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
-   * const authors = await em.upsertMany(Author, [{ email: 'foo@bar.com', age: 33 }, ...]);
-   * ```
-   *
-   * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
-   *
-   * ```ts
-   * // insert into "author" ("age", "email") values (33, 'foo@bar.com'), (666, 'lol@lol.lol') on conflict ("email") do update set "age" = excluded."age"
-   * // select "id" from "author" where "email" = 'foo@bar.com'
-   * const author = await em.upsertMany(Author, [
-   *   { email: 'foo@bar.com', age: 33 },
-   *   { email: 'lol@lol.lol', age: 666 },
-   * ]);
-   * ```
-   *
-   * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
-   *
-   * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
-   */
-  upsertMany<Entity extends object, Fields extends string = any>(
-    entityNameOrEntity: EntityName<Entity> | Entity[],
-    data?: (EntityData<Entity> | NoInfer<Entity>)[],
-    options?: UpsertManyOptions<Entity, Fields>,
-  ): Promise<Entity[]>;
-  /**
-   * Runs your callback wrapped inside a database transaction.
-   *
-   * If a transaction is already active, a new savepoint (nested transaction) will be created by default. This behavior
-   * can be controlled via the `propagation` option. Use the provided EntityManager instance for all operations that
-   * should be part of the transaction. You can safely use a global EntityManager instance from a DI container, as this
-   * method automatically creates an async context for the transaction.
-   *
-   * **Concurrency note:** When running multiple transactions concurrently (e.g. in parallel requests or jobs), use the
-   * `clear: true` option. This ensures the callback runs in a clear fork of the EntityManager, providing full isolation
-   * between concurrent transactional handlers. Using `clear: true` is an alternative to forking explicitly and calling
-   * the method on the new fork – it already provides the necessary isolation for safe concurrent usage.
-   *
-   * **Propagation note:** Changes made within a transaction (whether top-level or nested) are always propagated to the
-   * parent context, unless the parent context is a global one. If you want to avoid that, fork the EntityManager first
-   * and then call this method on the fork.
-   *
-   * **Example:**
-   * ```ts
-   * await em.transactional(async (em) => {
-   *   const author = new Author('Jon');
-   *   em.persist(author);
-   *   // flush is called automatically at the end of the callback
-   * });
-   * ```
-   */
-  transactional<T>(cb: (em: this) => T | Promise<T>, options?: TransactionOptions): Promise<T>;
-  /**
-   * Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.
-   */
-  begin(options?: Omit<TransactionOptions, 'ignoreNestedTransactions'>): Promise<void>;
-  /**
-   * Commits the transaction bound to this EntityManager. Flushes before doing the actual commit query.
-   */
-  commit(): Promise<void>;
-  /**
-   * Rollbacks the transaction bound to this EntityManager.
-   */
-  rollback(): Promise<void>;
-  /**
-   * Runs your callback wrapped inside a database transaction.
-   */
-  lock<T extends object>(entity: T, lockMode: LockMode, options?: LockOptions | number | Date): Promise<void>;
-  /**
-   * Fires native insert query. Calling this has no side effects on the context (identity map).
-   */
-  insert<Entity extends object>(
-    entityNameOrEntity: EntityName<Entity> | Entity,
-    data?: RequiredEntityData<Entity> | Entity,
-    options?: NativeInsertUpdateOptions<Entity>,
-  ): Promise<Primary<Entity>>;
-  /**
-   * Fires native multi-insert query. Calling this has no side effects on the context (identity map).
-   */
-  insertMany<Entity extends object>(
-    entityNameOrEntities: EntityName<Entity> | Entity[],
-    data?: RequiredEntityData<Entity>[] | Entity[],
-    options?: NativeInsertUpdateOptions<Entity>,
-  ): Promise<Primary<Entity>[]>;
-  /**
-   * Fires native update query. Calling this has no side effects on the context (identity map).
-   */
-  nativeUpdate<Entity extends object>(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<NoInfer<Entity>>,
-    data: EntityData<Entity>,
-    options?: UpdateOptions<Entity>,
-  ): Promise<number>;
-  /**
-   * Fires native delete query. Calling this has no side effects on the context (identity map).
-   */
-  nativeDelete<Entity extends object>(
-    entityName: EntityName<Entity>,
-    where: FilterQuery<NoInfer<Entity>>,
-    options?: DeleteOptions<Entity>,
-  ): Promise<number>;
-  /**
-   * Maps raw database result to an entity and merges it to this EntityManager.
-   */
-  map<Entity extends object>(
-    entityName: EntityName<Entity>,
-    result: EntityDictionary<Entity>,
-    options?: {
-      schema?: string;
-    },
-  ): Entity;
-  /**
-   * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
-   * via second parameter. By default, it will return already loaded entities without modifying them.
-   */
-  merge<Entity extends object>(entity: Entity, options?: MergeOptions): Entity;
-  /**
-   * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
-   * via second parameter. By default, it will return already loaded entities without modifying them.
-   */
-  merge<Entity extends object>(
-    entityName: EntityName<Entity>,
-    data: EntityData<Entity> | EntityDTO<Entity>,
-    options?: MergeOptions,
-  ): Entity;
-  /**
-   * Creates new instance of given entity and populates it with given data.
-   * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
-   * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
-   * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
-   * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
-   * `em.create()` will pass the data into it (unless we have a property named `data` too).
-   *
-   * The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
-   * symbol to omit some properties from this check without making them optional. Alternatively, use `partial: true`
-   * in the options to disable the strict checks for required properties. This option has no effect on runtime.
-   *
-   * The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
-   * behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
-   */
-  create<
-    Entity extends object,
-    Convert extends boolean = false,
-    Data extends RequiredEntityData<Entity, never, Convert> = RequiredEntityData<Entity, never, Convert>,
-  >(
-    entityName: EntityName<Entity>,
-    data: Data & IsSubset<RequiredEntityData<Entity, never, Convert>, Data>,
-    options?: CreateOptions<Convert>,
-  ): Entity;
-  /**
-   * Creates new instance of given entity and populates it with given data.
-   * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
-   * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
-   * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
-   * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
-   * `em.create()` will pass the data into it (unless we have a property named `data` too).
-   *
-   * The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
-   * symbol to omit some properties from this check without making them optional. Alternatively, use `partial: true`
-   * in the options to disable the strict checks for required properties. This option has no effect on runtime.
-   *
-   * The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
-   * behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
-   */
-  create<
-    Entity extends object,
-    Convert extends boolean = false,
-    Data extends EntityData<Entity, Convert> = EntityData<Entity, Convert>,
-  >(
-    entityName: EntityName<Entity>,
-    data: Data & IsSubset<EntityData<Entity, Convert>, Data>,
-    options: CreateOptions<Convert> & {
-      partial: true;
-    },
-  ): Entity;
-  /**
-   * Shortcut for `wrap(entity).assign(data, { em })`
-   */
-  assign<
-    Entity extends object,
-    Naked extends FromEntityType<Entity> = FromEntityType<Entity>,
-    Convert extends boolean = false,
-    Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> =
-      | EntityData<Naked, Convert>
-      | Partial<EntityDTO<Naked>>,
-  >(
-    entity: Entity | Partial<Entity>,
-    data: Data & IsSubset<EntityData<Naked, Convert>, Data>,
-    options?: AssignOptions<Convert>,
-  ): MergeSelected<Entity, Naked, keyof Data & string>;
-  /**
-   * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
-   * The key option specifies which property to use for identity map lookup instead of the primary key.
-   */
-  getReference<Entity extends object, K extends string & keyof Entity>(
-    entityName: EntityName<Entity>,
-    id: Entity[K],
-    options: Omit<GetReferenceOptions, 'key' | 'wrapped'> & {
-      key: K;
-      wrapped: true;
-    },
-  ): Ref<Entity>;
-  /**
-   * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
-   * The key option specifies which property to use for identity map lookup instead of the primary key.
-   */
-  getReference<Entity extends object, K extends string & keyof Entity>(
-    entityName: EntityName<Entity>,
-    id: Entity[K],
-    options: Omit<GetReferenceOptions, 'key'> & {
-      key: K;
-      wrapped?: false;
-    },
-  ): Entity;
-  /**
-   * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
-   */
-  getReference<Entity extends object>(
-    entityName: EntityName<Entity>,
-    id: Primary<Entity>,
-    options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
-      wrapped: true;
-    },
-  ): Ref<Entity>;
-  /**
-   * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
-   */
-  getReference<Entity extends object>(entityName: EntityName<Entity>, id: Primary<Entity> | Primary<Entity>[]): Entity;
-  /**
-   * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
-   */
-  getReference<Entity extends object>(
-    entityName: EntityName<Entity>,
-    id: Primary<Entity>,
-    options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
-      wrapped: false;
-    },
-  ): Entity;
-  /**
-   * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
-   */
-  getReference<Entity extends object>(
-    entityName: EntityName<Entity>,
-    id: Primary<Entity>,
-    options?: GetReferenceOptions,
-  ): Entity | Reference<Entity>;
-  /**
-   * Returns total number of entities matching your `where` query.
-   */
-  count<Entity extends object, Hint extends string = never>(
-    entityName: EntityName<Entity>,
-    where?: FilterQuery<NoInfer<Entity>>,
-    options?: CountOptions<Entity, Hint>,
-  ): Promise<number>;
-  /**
-   * Tells the EntityManager to make an instance managed and persistent.
-   * The entity will be entered into the database at or before transaction commit or as a result of the flush operation.
-   */
-  persist<Entity extends object>(entity: Entity | Reference<Entity> | Iterable<Entity | Reference<Entity>>): this;
-  /**
-   * Marks entity for removal.
-   * A removed entity will be removed from the database at or before transaction commit or as a result of the flush operation.
-   *
-   * To remove entities by condition, use `em.nativeDelete()`.
-   */
-  remove<Entity extends object>(entity: Entity | Reference<Entity> | Iterable<Entity | Reference<Entity>>): this;
-  /**
-   * Flushes all changes to objects that have been queued up to now to the database.
-   * This effectively synchronizes the in-memory state of managed objects with the database.
-   */
-  flush(): Promise<void>;
-  /**
-   * @internal
-   */
-  tryFlush<Entity extends object>(
-    entityName: EntityName<Entity>,
-    options: {
-      flushMode?: FlushMode | AnyString;
-    },
-  ): Promise<void>;
-  /**
-   * Clears the EntityManager. All entities that are currently managed by this EntityManager become detached.
-   */
-  clear(): void;
-  /**
-   * Checks whether given property can be populated on the entity.
-   */
-  canPopulate<Entity extends object>(entityName: EntityName<Entity>, property: string): boolean;
-  /**
-   * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
-   */
-  populate<
-    Entity extends object,
-    Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>,
-    Hint extends string = never,
-    Fields extends string = never,
-    Excludes extends string = never,
-  >(
-    entities: Entity,
-    populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false,
-    options?: EntityLoaderOptions<Naked, Fields, Excludes>,
-  ): Promise<
-    Entity extends object[]
-      ? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[]
-      : MergeLoaded<Entity, Naked, Hint, Fields, Excludes>
-  >;
-  /**
-   * Returns new EntityManager instance with its own identity map
-   */
-  fork(options?: ForkOptions): this;
-  /**
-   * Gets the UnitOfWork used by the EntityManager to coordinate operations.
-   */
-  getUnitOfWork(useContext?: boolean): UnitOfWork;
-  /**
-   * Gets the EntityFactory used by the EntityManager.
-   */
-  getEntityFactory(): EntityFactory;
-  /**
-   * @internal use `em.populate()` as the user facing API, this is exposed only for internal usage
-   */
-  getEntityLoader(): EntityLoader;
-  /**
-   * Gets the Hydrator used by the EntityManager.
-   */
-  getHydrator(): IHydrator;
-  /**
-   * Gets the EntityManager based on current transaction/request context.
-   * @internal
-   */
-  getContext(validate?: boolean): this;
-  /** Gets the EventManager instance used by this EntityManager. */
-  getEventManager(): EventManager;
-  /**
-   * Checks whether this EntityManager is currently operating inside a database transaction.
-   */
-  isInTransaction(): boolean;
-  /**
-   * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
-   */
-  getTransactionContext<T extends Transaction = Transaction>(): T | undefined;
-  /**
-   * Sets the transaction context.
-   */
-  setTransactionContext(ctx?: Transaction): void;
-  /**
-   * Resets the transaction context.
-   */
-  resetTransactionContext(): void;
-  /**
-   * Gets the `MetadataStorage`.
-   */
-  getMetadata(): MetadataStorage;
-  /**
-   * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
-   */
-  getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
-  /**
-   * Gets the EntityComparator.
-   */
-  getComparator(): EntityComparator;
-  private checkLockRequirements;
-  private lockAndPopulate;
-  private buildFields;
-  /** @internal */
-  preparePopulate<Entity extends object>(
-    entityName: EntityName<Entity>,
-    options: Pick<
-      FindOptions<Entity, any, any, any>,
-      'populate' | 'strategy' | 'fields' | 'flags' | 'filters' | 'exclude' | 'populateHints'
-    >,
-    validate?: boolean,
-  ): Promise<PopulateOptions<Entity>[]>;
-  /**
-   * when the entity is found in identity map, we check if it was partially loaded or we are trying to populate
-   * some additional lazy properties, if so, we reload and merge the data from database
-   */
-  protected shouldRefresh<
-    T extends object,
-    P extends string = never,
-    F extends string = never,
-    E extends string = never,
-  >(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
-  protected prepareOptions(
-    options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any>,
-  ): void;
-  /**
-   * @internal
-   */
-  cacheKey<T extends object>(
-    entityName: EntityName<T>,
-    options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any> | CountOptions<T, any>,
-    method: string,
-    where: FilterQuery<T>,
-  ): unknown[];
-  /**
-   * @internal
-   */
-  tryCache<T extends object, R>(
-    entityName: EntityName<T>,
-    config: boolean | number | [string, number] | undefined,
-    key: unknown,
-    refresh?: boolean,
-    merge?: boolean,
-  ): Promise<
-    | {
+    #private;
+    readonly config: Configuration;
+    protected readonly driver: Driver;
+    protected readonly metadata: MetadataStorage;
+    protected readonly eventManager: EventManager;
+    /** @internal */
+    readonly '~entities'?: unknown;
+    /** @internal */
+    readonly _id: number;
+    /** Whether this is the global (root) EntityManager instance. */
+    readonly global = false;
+    /** The context name of this EntityManager, derived from the ORM configuration. */
+    readonly name: string;
+    protected loggerContext?: Dictionary;
+    /**
+     * @internal
+     */
+    constructor(config: Configuration, driver: Driver, metadata: MetadataStorage, useContext?: boolean, eventManager?: EventManager);
+    /**
+     * Gets the Driver instance used by this EntityManager.
+     * Driver is singleton, for one MikroORM instance, only one driver is created.
+     */
+    getDriver(): Driver;
+    /**
+     * Gets the Connection instance, by default returns write connection
+     */
+    getConnection(type?: ConnectionType): ReturnType<Driver['getConnection']>;
+    /**
+     * Gets the platform instance. Just like the driver, platform is singleton, one for a MikroORM instance.
+     */
+    getPlatform(): ReturnType<Driver['getPlatform']>;
+    /**
+     * Gets repository for given entity. You can pass either string name or entity class reference.
+     */
+    getRepository<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(entityName: EntityName<Entity>): GetRepository<Entity, Repository>;
+    /**
+     * Shortcut for `em.getRepository()`.
+     */
+    repo<Entity extends object, Repository extends EntityRepository<Entity> = EntityRepository<Entity>>(entityName: EntityName<Entity>): GetRepository<Entity, Repository>;
+    /**
+     * Finds all entities matching your `where` query. You can pass additional options via the `options` parameter.
+     */
+    find<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    /**
+     * Finds all entities and returns an async iterable (async generator) that yields results one by one.
+     * The results are merged and mapped to entity instances, without adding them to the identity map.
+     * You can disable merging by passing the options `{ mergeResults: false }`.
+     * With `mergeResults` disabled, to-many collections will contain at most one item, and you will get duplicate
+     * root entities when there are multiple items in the populated collection.
+     * This is useful for processing large datasets without loading everything into memory at once.
+     *
+     * ```ts
+     * const stream = em.stream(Book, { populate: ['author'] });
+     *
+     * for await (const book of stream) {
+     *   // book is an instance of Book entity
+     *   console.log(book.title, book.author.name);
+     * }
+     * ```
+     */
+    stream<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, options?: StreamOptions<NoInfer<Entity>, Hint, Fields, Excludes>): AsyncIterableIterator<Loaded<Entity, Hint, Fields, Excludes>>;
+    /**
+     * Finds all entities of given type, optionally matching the `where` condition provided in the `options` parameter.
+     */
+    findAll<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, options?: FindAllOptions<NoInfer<Entity>, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>[]>;
+    private getPopulateWhere;
+    /**
+     * Registers global filter to this entity manager. Global filters are enabled by default (unless disabled via last parameter).
+     */
+    addFilter<T extends EntityName | readonly EntityName[]>(options: FilterDef<T>): void;
+    /**
+     * Sets filter parameter values globally inside context defined by this entity manager.
+     * If you want to set shared value for all contexts, be sure to use the root entity manager.
+     */
+    setFilterParams(name: string, args: Dictionary): void;
+    /**
+     * Returns filter parameters for given filter set in this context.
+     */
+    getFilterParams<T extends Dictionary = Dictionary>(name: string): T;
+    /**
+     * Sets logger context for this entity manager.
+     */
+    setLoggerContext(context: Dictionary): void;
+    /**
+     * Gets logger context for this entity manager.
+     */
+    getLoggerContext<T extends Dictionary = Dictionary>(options?: {
+        disableContextResolution?: boolean;
+    }): T;
+    /** Sets the flush mode for this EntityManager. Pass `undefined` to reset to the global default. */
+    setFlushMode(flushMode?: FlushMode | `${FlushMode}`): void;
+    protected processWhere<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<Entity>, options: FindOptions<Entity, Hint, Fields, Excludes> | FindOneOptions<Entity, Hint, Fields, Excludes>, type: 'read' | 'update' | 'delete'): Promise<FilterQuery<Entity>>;
+    protected processUnionWhere<Entity extends object, Hint extends string = never>(entityName: EntityName<Entity>, options: FindOptions<Entity, Hint, any, any> | CountOptions<Entity, Hint> | UpdateOptions<Entity> | DeleteOptions<Entity>, type: 'read' | 'update' | 'delete'): Promise<void>;
+    protected applyDiscriminatorCondition<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity>): FilterQuery<Entity>;
+    protected createPopulateWhere<Entity extends object>(cond: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any> | CountOptions<Entity, any>): ObjectQuery<Entity>;
+    protected getJoinedFilters<Entity extends object>(meta: EntityMetadata<Entity>, options: FindOptions<Entity, any, any, any> | FindOneOptions<Entity, any, any, any>): Promise<ObjectQuery<Entity> | undefined>;
+    /**
+     * When filters are active on M:1 or 1:1 relations, we need to ref join them eagerly as they might affect the FK value.
+     */
+    protected autoJoinRefsForFilters<T extends object>(meta: EntityMetadata<T>, options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, parent?: {
+        class: EntityClass;
+        propName: string;
+    }): Promise<void>;
+    /**
+     * @internal
+     */
+    applyFilters<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<Entity> | undefined, options: FilterOptions | undefined, type: 'read' | 'update' | 'delete', findOptions?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>): Promise<FilterQuery<Entity> | undefined>;
+    /**
+     * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as tuple
+     * where the first element is the array of entities, and the second is the count.
+     */
+    findAndCount<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOptions<Entity, Hint, Fields, Excludes>): Promise<[Loaded<Entity, Hint, Fields, Excludes>[], number]>;
+    /**
+     * Calls `em.find()` and `em.count()` with the same arguments (where applicable) and returns the results as {@apilink Cursor} object.
+     * Supports `before`, `after`, `first` and `last` options while disallowing `limit` and `offset`. Explicit `orderBy` option
+     * is required.
+     *
+     * Use `first` and `after` for forward pagination, or `last` and `before` for backward pagination.
+     *
+     * - `first` and `last` are numbers and serve as an alternative to `offset`, those options are mutually exclusive, use only one at a time
+     * - `before` and `after` specify the previous cursor value, it can be one of the:
+     *     - `Cursor` instance
+     *     - opaque string provided by `startCursor/endCursor` properties
+     *     - POJO/entity instance
+     *
+     * ```ts
+     * const currentCursor = await em.findByCursor(User, {
+     *   first: 10,
+     *   after: previousCursor, // cursor instance
+     *   orderBy: { id: 'desc' },
+     * });
+     *
+     * // to fetch next page
+     * const nextCursor = await em.findByCursor(User, {
+     *   first: 10,
+     *   after: currentCursor.endCursor, // opaque string
+     *   orderBy: { id: 'desc' },
+     * });
+     *
+     * // to fetch next page
+     * const nextCursor2 = await em.findByCursor(User, {
+     *   first: 10,
+     *   after: { id: lastSeenId }, // entity-like POJO
+     *   orderBy: { id: 'desc' },
+     * });
+     * ```
+     *
+     * The options also support an `includeCount` (true by default) option. If set to false, the `totalCount` is not
+     * returned as part of the cursor. This is useful for performance reason, when you don't care about the total number
+     * of pages.
+     *
+     * The `Cursor` object provides the following interface:
+     *
+     * ```ts
+     * Cursor<User> {
+     *   items: [
+     *     User { ... },
+     *     User { ... },
+     *     User { ... },
+     *   ],
+     *   totalCount: 50, // not included if `includeCount: false`
+     *   startCursor: 'WzRd',
+     *   endCursor: 'WzZd',
+     *   hasPrevPage: true,
+     *   hasNextPage: true,
+     * }
+     * ```
+     */
+    findByCursor<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never, IncludeCount extends boolean = true>(entityName: EntityName<Entity>, options: FindByCursorOptions<Entity, Hint, Fields, Excludes, IncludeCount>): Promise<Cursor<Entity, Hint, Fields, Excludes, IncludeCount>>;
+    /**
+     * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
+     * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
+     * in database, the method throws an error just like `em.findOneOrFail()` (and respects the same config options).
+     */
+    refreshOrFail<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entity: Entity, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true>>;
+    /**
+     * Refreshes the persistent state of an entity from the database, overriding any local changes that have not yet been
+     * persisted. Returns the same entity instance (same object reference), but re-hydrated. If the entity is no longer
+     * in database, the method returns `null`.
+     */
+    refresh<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entity: Entity, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<MergeLoaded<Entity, Naked, Hint, Fields, Excludes, true> | null>;
+    /**
+     * Finds first entity matching your `where` query.
+     */
+    findOne<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+    /**
+     * Finds first entity matching your `where` query. If nothing found, it will throw an error.
+     * If the `strict` option is specified and nothing is found or more than one matching entity is found, it will throw an error.
+     * You can override the factory for creating this method via `options.failHandler` locally
+     * or via `Configuration.findOneOrFailHandler` (`findExactlyOneOrFailHandler` when specifying `strict`) globally.
+     */
+    findOneOrFail<Entity extends object, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: FindOneOrFailOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes>>;
+    /**
+     * Creates or updates the entity, based on whether it is already present in the database.
+     * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
+     * entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * const author = await em.upsert(Author, { email: 'foo@bar.com', age: 33 });
+     * ```
+     *
+     * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * // select "id" from "author" where "email" = 'foo@bar.com'
+     * const author = await em.upsert(Author, { email: 'foo@bar.com', age: 33 });
+     * ```
+     *
+     * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
+     *
+     * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
+     */
+    upsert<Entity extends object, Fields extends string = any>(entityNameOrEntity: EntityName<Entity> | Entity, data?: EntityData<Entity> | NoInfer<Entity>, options?: UpsertOptions<Entity, Fields>): Promise<Entity>;
+    /**
+     * Creates or updates the entity, based on whether it is already present in the database.
+     * This method performs an `insert on conflict merge` query ensuring the database is in sync, returning a managed
+     * entity instance. The method accepts either `entityName` together with the entity `data`, or just entity instance.
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com') on conflict ("email") do update set "age" = 41
+     * const authors = await em.upsertMany(Author, [{ email: 'foo@bar.com', age: 33 }, ...]);
+     * ```
+     *
+     * The entity data needs to contain either the primary key, or any other unique property. Let's consider the following example, where `Author.email` is a unique property:
+     *
+     * ```ts
+     * // insert into "author" ("age", "email") values (33, 'foo@bar.com'), (666, 'lol@lol.lol') on conflict ("email") do update set "age" = excluded."age"
+     * // select "id" from "author" where "email" = 'foo@bar.com'
+     * const author = await em.upsertMany(Author, [
+     *   { email: 'foo@bar.com', age: 33 },
+     *   { email: 'lol@lol.lol', age: 666 },
+     * ]);
+     * ```
+     *
+     * Depending on the driver support, this will either use a returning query, or a separate select query, to fetch the primary key if it's missing from the `data`.
+     *
+     * If the entity is already present in current context, there won't be any queries - instead, the entity data will be assigned and an explicit `flush` will be required for those changes to be persisted.
+     */
+    upsertMany<Entity extends object, Fields extends string = any>(entityNameOrEntity: EntityName<Entity> | Entity[], data?: (EntityData<Entity> | NoInfer<Entity>)[], options?: UpsertManyOptions<Entity, Fields>): Promise<Entity[]>;
+    /**
+     * Runs your callback wrapped inside a database transaction.
+     *
+     * If a transaction is already active, a new savepoint (nested transaction) will be created by default. This behavior
+     * can be controlled via the `propagation` option. Use the provided EntityManager instance for all operations that
+     * should be part of the transaction. You can safely use a global EntityManager instance from a DI container, as this
+     * method automatically creates an async context for the transaction.
+     *
+     * **Concurrency note:** When running multiple transactions concurrently (e.g. in parallel requests or jobs), use the
+     * `clear: true` option. This ensures the callback runs in a clear fork of the EntityManager, providing full isolation
+     * between concurrent transactional handlers. Using `clear: true` is an alternative to forking explicitly and calling
+     * the method on the new fork – it already provides the necessary isolation for safe concurrent usage.
+     *
+     * **Propagation note:** Changes made within a transaction (whether top-level or nested) are always propagated to the
+     * parent context, unless the parent context is a global one. If you want to avoid that, fork the EntityManager first
+     * and then call this method on the fork.
+     *
+     * **Example:**
+     * ```ts
+     * await em.transactional(async (em) => {
+     *   const author = new Author('Jon');
+     *   em.persist(author);
+     *   // flush is called automatically at the end of the callback
+     * });
+     * ```
+     */
+    transactional<T>(cb: (em: this) => T | Promise<T>, options?: TransactionOptions): Promise<T>;
+    /**
+     * Starts new transaction bound to this EntityManager. Use `ctx` parameter to provide the parent when nesting transactions.
+     */
+    begin(options?: Omit<TransactionOptions, 'ignoreNestedTransactions'>): Promise<void>;
+    /**
+     * Commits the transaction bound to this EntityManager. Flushes before doing the actual commit query.
+     */
+    commit(): Promise<void>;
+    /**
+     * Rollbacks the transaction bound to this EntityManager.
+     */
+    rollback(): Promise<void>;
+    /**
+     * Runs your callback wrapped inside a database transaction.
+     */
+    lock<T extends object>(entity: T, lockMode: LockMode, options?: LockOptions | number | Date): Promise<void>;
+    /**
+     * Fires native insert query. Calling this has no side effects on the context (identity map).
+     */
+    insert<Entity extends object>(entityNameOrEntity: EntityName<Entity> | Entity, data?: RequiredEntityData<Entity> | Entity, options?: NativeInsertUpdateOptions<Entity>): Promise<Primary<Entity>>;
+    /**
+     * Fires native multi-insert query. Calling this has no side effects on the context (identity map).
+     */
+    insertMany<Entity extends object>(entityNameOrEntities: EntityName<Entity> | Entity[], data?: RequiredEntityData<Entity>[] | Entity[], options?: NativeInsertUpdateOptions<Entity>): Promise<Primary<Entity>[]>;
+    /**
+     * Fires native update query. Calling this has no side effects on the context (identity map).
+     */
+    nativeUpdate<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, data: EntityData<Entity>, options?: UpdateOptions<Entity>): Promise<number>;
+    /**
+     * Fires native delete query. Calling this has no side effects on the context (identity map).
+     */
+    nativeDelete<Entity extends object>(entityName: EntityName<Entity>, where: FilterQuery<NoInfer<Entity>>, options?: DeleteOptions<Entity>): Promise<number>;
+    /**
+     * Maps raw database result to an entity and merges it to this EntityManager.
+     */
+    map<Entity extends object>(entityName: EntityName<Entity>, result: EntityDictionary<Entity>, options?: {
+        schema?: string;
+    }): Entity;
+    /**
+     * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
+     * via second parameter. By default, it will return already loaded entities without modifying them.
+     */
+    merge<Entity extends object>(entity: Entity, options?: MergeOptions): Entity;
+    /**
+     * Merges given entity to this EntityManager so it becomes managed. You can force refreshing of existing entities
+     * via second parameter. By default, it will return already loaded entities without modifying them.
+     */
+    merge<Entity extends object>(entityName: EntityName<Entity>, data: EntityData<Entity> | EntityDTO<Entity>, options?: MergeOptions): Entity;
+    /**
+     * Creates new instance of given entity and populates it with given data.
+     * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
+     * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
+     * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
+     * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
+     * `em.create()` will pass the data into it (unless we have a property named `data` too).
+     *
+     * The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
+     * symbol to omit some properties from this check without making them optional. Alternatively, use `partial: true`
+     * in the options to disable the strict checks for required properties. This option has no effect on runtime.
+     *
+     * The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
+     * behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
+     */
+    create<Entity extends object, Convert extends boolean = false, Data extends RequiredEntityData<Entity, never, Convert> = RequiredEntityData<Entity, never, Convert>>(entityName: EntityName<Entity>, data: Data & IsSubset<RequiredEntityData<Entity, never, Convert>, Data>, options?: CreateOptions<Convert>): Entity;
+    /**
+     * Creates new instance of given entity and populates it with given data.
+     * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.
+     * The constructor will be given parameters based on the defined constructor of the entity. If the constructor
+     * parameter matches a property name, its value will be extracted from `data`. If no matching property exists,
+     * the whole `data` parameter will be passed. This means we can also define `constructor(data: Partial<T>)` and
+     * `em.create()` will pass the data into it (unless we have a property named `data` too).
+     *
+     * The parameters are strictly checked, you need to provide all required properties. You can use `OptionalProps`
+     * symbol to omit some properties from this check without making them optional. Alternatively, use `partial: true`
+     * in the options to disable the strict checks for required properties. This option has no effect on runtime.
+     *
+     * The newly created entity will be automatically marked for persistence via `em.persist` unless you disable this
+     * behavior, either locally via `persist: false` option, or globally via `persistOnCreate` ORM config option.
+     */
+    create<Entity extends object, Convert extends boolean = false, Data extends EntityData<Entity, Convert> = EntityData<Entity, Convert>>(entityName: EntityName<Entity>, data: Data & IsSubset<EntityData<Entity, Convert>, Data>, options: CreateOptions<Convert> & {
+        partial: true;
+    }): Entity;
+    /**
+     * Shortcut for `wrap(entity).assign(data, { em })`
+     */
+    assign<Entity extends object, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(entity: Entity | Partial<Entity>, data: Data & IsSubset<EntityData<Naked, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
+    /**
+     * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
+     * The key option specifies which property to use for identity map lookup instead of the primary key.
+     */
+    getReference<Entity extends object, K extends string & keyof Entity>(entityName: EntityName<Entity>, id: Entity[K], options: Omit<GetReferenceOptions, 'key' | 'wrapped'> & {
+        key: K;
+        wrapped: true;
+    }): Ref<Entity>;
+    /**
+     * Gets a reference to the entity identified by the given type and alternate key property without actually loading it.
+     * The key option specifies which property to use for identity map lookup instead of the primary key.
+     */
+    getReference<Entity extends object, K extends string & keyof Entity>(entityName: EntityName<Entity>, id: Entity[K], options: Omit<GetReferenceOptions, 'key'> & {
+        key: K;
+        wrapped?: false;
+    }): Entity;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference<Entity extends object>(entityName: EntityName<Entity>, id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
+        wrapped: true;
+    }): Ref<Entity>;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference<Entity extends object>(entityName: EntityName<Entity>, id: Primary<Entity> | Primary<Entity>[]): Entity;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference<Entity extends object>(entityName: EntityName<Entity>, id: Primary<Entity>, options: Omit<GetReferenceOptions, 'wrapped' | 'key'> & {
+        wrapped: false;
+    }): Entity;
+    /**
+     * Gets a reference to the entity identified by the given type and identifier without actually loading it, if the entity is not yet loaded
+     */
+    getReference<Entity extends object>(entityName: EntityName<Entity>, id: Primary<Entity>, options?: GetReferenceOptions): Entity | Reference<Entity>;
+    /**
+     * Returns total number of entities matching your `where` query.
+     */
+    count<Entity extends object, Hint extends string = never>(entityName: EntityName<Entity>, where?: FilterQuery<NoInfer<Entity>>, options?: CountOptions<Entity, Hint>): Promise<number>;
+    /**
+     * Tells the EntityManager to make an instance managed and persistent.
+     * The entity will be entered into the database at or before transaction commit or as a result of the flush operation.
+     */
+    persist<Entity extends object>(entity: Entity | Reference<Entity> | Iterable<Entity | Reference<Entity>>): this;
+    /**
+     * Marks entity for removal.
+     * A removed entity will be removed from the database at or before transaction commit or as a result of the flush operation.
+     *
+     * To remove entities by condition, use `em.nativeDelete()`.
+     */
+    remove<Entity extends object>(entity: Entity | Reference<Entity> | Iterable<Entity | Reference<Entity>>): this;
+    /**
+     * Flushes all changes to objects that have been queued up to now to the database.
+     * This effectively synchronizes the in-memory state of managed objects with the database.
+     */
+    flush(): Promise<void>;
+    /**
+     * @internal
+     */
+    tryFlush<Entity extends object>(entityName: EntityName<Entity>, options: {
+        flushMode?: FlushMode | AnyString;
+    }): Promise<void>;
+    /**
+     * Clears the EntityManager. All entities that are currently managed by this EntityManager become detached.
+     */
+    clear(): void;
+    /**
+     * Checks whether given property can be populated on the entity.
+     */
+    canPopulate<Entity extends object>(entityName: EntityName<Entity>, property: string): boolean;
+    /**
+     * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
+     */
+    populate<Entity extends object, Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entities: Entity, populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Entity extends object[] ? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Entity, Naked, Hint, Fields, Excludes>>;
+    /**
+     * Returns new EntityManager instance with its own identity map
+     */
+    fork(options?: ForkOptions): this;
+    /**
+     * Gets the UnitOfWork used by the EntityManager to coordinate operations.
+     */
+    getUnitOfWork(useContext?: boolean): UnitOfWork;
+    /**
+     * Gets the EntityFactory used by the EntityManager.
+     */
+    getEntityFactory(): EntityFactory;
+    /**
+     * @internal use `em.populate()` as the user facing API, this is exposed only for internal usage
+     */
+    getEntityLoader(): EntityLoader;
+    /**
+     * Gets the Hydrator used by the EntityManager.
+     */
+    getHydrator(): IHydrator;
+    /**
+     * Gets the EntityManager based on current transaction/request context.
+     * @internal
+     */
+    getContext(validate?: boolean): this;
+    /** Gets the EventManager instance used by this EntityManager. */
+    getEventManager(): EventManager;
+    /**
+     * Checks whether this EntityManager is currently operating inside a database transaction.
+     */
+    isInTransaction(): boolean;
+    /**
+     * Gets the transaction context (driver dependent object used to make sure queries are executed on same connection).
+     */
+    getTransactionContext<T extends Transaction = Transaction>(): T | undefined;
+    /**
+     * Sets the transaction context.
+     */
+    setTransactionContext(ctx?: Transaction): void;
+    /**
+     * Resets the transaction context.
+     */
+    resetTransactionContext(): void;
+    /**
+     * Gets the `MetadataStorage`.
+     */
+    getMetadata(): MetadataStorage;
+    /**
+     * Gets the `EntityMetadata` instance when provided with the `entityName` parameter.
+     */
+    getMetadata<Entity extends object>(entityName: EntityName<Entity>): EntityMetadata<Entity>;
+    /**
+     * Gets the EntityComparator.
+     */
+    getComparator(): EntityComparator;
+    private checkLockRequirements;
+    private lockAndPopulate;
+    private buildFields;
+    /** @internal */
+    preparePopulate<Entity extends object>(entityName: EntityName<Entity>, options: Pick<FindOptions<Entity, any, any, any>, 'populate' | 'strategy' | 'fields' | 'flags' | 'filters' | 'exclude' | 'populateHints'>, validate?: boolean): Promise<PopulateOptions<Entity>[]>;
+    /**
+     * when the entity is found in identity map, we check if it was partially loaded or we are trying to populate
+     * some additional lazy properties, if so, we reload and merge the data from database
+     */
+    protected shouldRefresh<T extends object, P extends string = never, F extends string = never, E extends string = never>(meta: EntityMetadata<T>, entity: T, options: FindOneOptions<T, P, F, E>): boolean;
+    protected prepareOptions(options: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any> | CountOptions<any, any>): void;
+    /**
+     * @internal
+     */
+    cacheKey<T extends object>(entityName: EntityName<T>, options: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any> | CountOptions<T, any>, method: string, where: FilterQuery<T>): unknown[];
+    /**
+     * @internal
+     */
+    tryCache<T extends object, R>(entityName: EntityName<T>, config: boolean | number | [string, number] | undefined, key: unknown, refresh?: boolean, merge?: boolean): Promise<{
         data?: R | null;
         key: string;
-      }
-    | undefined
-  >;
-  /**
-   * @internal
-   */
-  storeCache<T>(
-    config: boolean | number | [string, number] | undefined,
-    key: {
-      key: string;
-    },
-    data: T | (() => T),
-  ): Promise<void>;
-  /**
-   * Clears result cache for given cache key. If we want to be able to call this method,
-   * we need to set the cache key explicitly when storing the cache.
-   *
-   * ```ts
-   * // set the cache key to 'book-cache-key', with expiration of 60s
-   * const res = await em.find(Book, { ... }, { cache: ['book-cache-key', 60_000] });
-   *
-   * // clear the cache key by name
-   * await em.clearCache('book-cache-key');
-   * ```
-   */
-  clearCache(cacheKey: string): Promise<void>;
-  /**
-   * Returns the default schema of this EntityManager. Respects the context, so global EM will give you the contextual schema
-   * if executed inside request context handler.
-   */
-  get schema(): string | undefined;
-  /**
-   * Sets the default schema of this EntityManager. Respects the context, so global EM will set the contextual schema
-   * if executed inside request context handler.
-   */
-  set schema(schema: string | null | undefined);
-  /** @internal */
-  getDataLoader(type: 'ref' | '1:m' | 'm:n'): Promise<any>;
-  /**
-   * Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
-   * if executed inside request context handler.
-   */
-  get id(): number;
+    } | undefined>;
+    /**
+     * @internal
+     */
+    storeCache<T>(config: boolean | number | [string, number] | undefined, key: {
+        key: string;
+    }, data: T | (() => T)): Promise<void>;
+    /**
+     * Clears result cache for given cache key. If we want to be able to call this method,
+     * we need to set the cache key explicitly when storing the cache.
+     *
+     * ```ts
+     * // set the cache key to 'book-cache-key', with expiration of 60s
+     * const res = await em.find(Book, { ... }, { cache: ['book-cache-key', 60_000] });
+     *
+     * // clear the cache key by name
+     * await em.clearCache('book-cache-key');
+     * ```
+     */
+    clearCache(cacheKey: string): Promise<void>;
+    /**
+     * Returns the default schema of this EntityManager. Respects the context, so global EM will give you the contextual schema
+     * if executed inside request context handler.
+     */
+    get schema(): string | undefined;
+    /**
+     * Sets the default schema of this EntityManager. Respects the context, so global EM will set the contextual schema
+     * if executed inside request context handler.
+     */
+    set schema(schema: string | null | undefined);
+    /** @internal */
+    getDataLoader(type: 'ref' | '1:m' | 'm:n'): Promise<any>;
+    /**
+     * Returns the ID of this EntityManager. Respects the context, so global EM will give you the contextual ID
+     * if executed inside request context handler.
+     */
+    get id(): number;
 }
 export interface CreateOptions<Convert extends boolean> {
-  /** creates a managed entity instance instead, bypassing the constructor call */
-  managed?: boolean;
-  /** create entity in a specific schema - alternatively, use `wrap(entity).setSchema()` */
-  schema?: string;
-  /** persist the entity automatically - this is the default behavior and is also configurable globally via `persistOnCreate` option */
-  persist?: boolean;
-  /** this option disables the strict typing which requires all mandatory properties to have value, it has no effect on runtime */
-  partial?: boolean;
-  /** convert raw database values based on mapped types (by default, already converted values are expected) */
-  convertCustomTypes?: Convert;
-  /**
-   * Property `onCreate` hooks are normally executed during `flush` operation.
-   * With this option, they will be processed early inside `em.create()` method.
-   */
-  processOnCreateHooksEarly?: boolean;
+    /** creates a managed entity instance instead, bypassing the constructor call */
+    managed?: boolean;
+    /** create entity in a specific schema - alternatively, use `wrap(entity).setSchema()` */
+    schema?: string;
+    /** persist the entity automatically - this is the default behavior and is also configurable globally via `persistOnCreate` option */
+    persist?: boolean;
+    /** this option disables the strict typing which requires all mandatory properties to have value, it has no effect on runtime */
+    partial?: boolean;
+    /** convert raw database values based on mapped types (by default, already converted values are expected) */
+    convertCustomTypes?: Convert;
+    /**
+     * Property `onCreate` hooks are normally executed during `flush` operation.
+     * With this option, they will be processed early inside `em.create()` method.
+     */
+    processOnCreateHooksEarly?: boolean;
 }
 export interface MergeOptions {
-  refresh?: boolean;
-  convertCustomTypes?: boolean;
-  schema?: string;
-  disableContextResolution?: boolean;
-  validate?: boolean;
-  cascade?: boolean /** @default true */;
+    refresh?: boolean;
+    convertCustomTypes?: boolean;
+    schema?: string;
+    disableContextResolution?: boolean;
+    validate?: boolean;
+    cascade?: boolean /** @default true */;
 }
 export interface ForkOptions {
-  /** do we want a clear identity map? defaults to true */
-  clear?: boolean;
-  /** use request context? should be used only for top level request scope EM, defaults to false */
-  useContext?: boolean;
-  /** do we want to use fresh EventManager instance? defaults to false (global instance) */
-  freshEventManager?: boolean;
-  /** do we want to clone current EventManager instance? defaults to false (global instance) */
-  cloneEventManager?: boolean;
-  /** use this flag to ignore the current async context - this is required if we want to call `em.fork()` inside the `getContext` handler */
-  disableContextResolution?: boolean;
-  /** set flush mode for this fork, overrides the global option can be overridden locally via FindOptions */
-  flushMode?: FlushMode | `${FlushMode}`;
-  /** disable transactions for this fork */
-  disableTransactions?: boolean;
-  /** should we keep the transaction context of the parent EM? */
-  keepTransactionContext?: boolean;
-  /** default schema to use for this fork */
-  schema?: string;
-  /** default logger context, can be overridden via {@apilink FindOptions} */
-  loggerContext?: Dictionary;
+    /** do we want a clear identity map? defaults to true */
+    clear?: boolean;
+    /** use request context? should be used only for top level request scope EM, defaults to false */
+    useContext?: boolean;
+    /** do we want to use fresh EventManager instance? defaults to false (global instance) */
+    freshEventManager?: boolean;
+    /** do we want to clone current EventManager instance? defaults to false (global instance) */
+    cloneEventManager?: boolean;
+    /** use this flag to ignore the current async context - this is required if we want to call `em.fork()` inside the `getContext` handler */
+    disableContextResolution?: boolean;
+    /** set flush mode for this fork, overrides the global option can be overridden locally via FindOptions */
+    flushMode?: FlushMode | `${FlushMode}`;
+    /** disable transactions for this fork */
+    disableTransactions?: boolean;
+    /** should we keep the transaction context of the parent EM? */
+    keepTransactionContext?: boolean;
+    /** default schema to use for this fork */
+    schema?: string;
+    /** default logger context, can be overridden via {@apilink FindOptions} */
+    loggerContext?: Dictionary;
 }