@mikro-orm/core 7.0.2-dev.12 → 7.0.2-dev.14

package/EntityManager.d.ts

@@ -28,7 +28,9 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     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;
     /**
@@ -106,6 +108,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     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 = '*', 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>;
@@ -470,6 +473,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
      * @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.

package/EntityManager.js

@@ -31,7 +31,9 @@ export class EntityManager {
     static #counter = 1;
     /** @internal */
     _id = EntityManager.#counter++;
+    /** Whether this is the global (root) EntityManager instance. */
     global = false;
+    /** The context name of this EntityManager, derived from the ORM configuration. */
     name;
     #loaders = {};
     #repositoryMap = new Map();
@@ -284,6 +286,7 @@ export class EntityManager {
         em.loggerContext ??= {};
         return em.loggerContext;
     }
+    /** Sets the flush mode for this EntityManager. Pass `undefined` to reset to the global default. */
     setFlushMode(flushMode) {
         this.getContext(false).#flushMode = flushMode;
     }
@@ -1586,6 +1589,7 @@ export class EntityManager {
         }
         return em;
     }
+    /** Gets the EventManager instance used by this EntityManager. */
     getEventManager() {
         return this.eventManager;
     }

package/MikroORM.d.ts

@@ -40,7 +40,9 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
     em: EM & {
         '~entities'?: Entities;
     };
+    /** The database driver instance used by this ORM. */
     readonly driver: Driver;
+    /** The ORM configuration instance. */
     readonly config: Configuration<Driver>;
     /**
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.

package/MikroORM.js

@@ -72,7 +72,9 @@ export async function loadOptionalDependencies(options) {
 export class MikroORM {
     /** The global EntityManager instance. If you are using `RequestContext` helper, it will automatically pick the request specific context under the hood */
     em;
+    /** The database driver instance used by this ORM. */
     driver;
+    /** The ORM configuration instance. */
     config;
     #metadata;
     #logger;

package/cache/CacheAdapter.d.ts

@@ -1,3 +1,4 @@
+/** Interface for async-capable cache storage used by result cache and metadata cache. */
 export interface CacheAdapter {
     /**
      * Gets the items under `name` key from the cache.
@@ -20,6 +21,7 @@ export interface CacheAdapter {
      */
     close?(): void | Promise<void>;
 }
+/** Synchronous variant of CacheAdapter, used for metadata cache where async access is not needed. */
 export interface SyncCacheAdapter extends CacheAdapter {
     /**
      * Gets the items under `name` key from the cache.

package/cache/GeneratedCacheAdapter.d.ts

@@ -1,5 +1,6 @@
 import type { CacheAdapter } from './CacheAdapter.js';
 import type { Dictionary } from '../typings.js';
+/** Cache adapter backed by pre-generated static data, typically produced by the CLI cache:generate command. */
 export declare class GeneratedCacheAdapter implements CacheAdapter {
     #private;
     constructor(options: {

package/cache/GeneratedCacheAdapter.js

@@ -1,3 +1,4 @@
+/** Cache adapter backed by pre-generated static data, typically produced by the CLI cache:generate command. */
 export class GeneratedCacheAdapter {
     #data;
     constructor(options) {

package/cache/MemoryCacheAdapter.d.ts

@@ -1,4 +1,5 @@
 import type { CacheAdapter } from './CacheAdapter.js';
+/** In-memory cache adapter with time-based expiration. Used as the default result cache. */
 export declare class MemoryCacheAdapter implements CacheAdapter {
     #private;
     constructor(options: {

package/cache/MemoryCacheAdapter.js

@@ -1,3 +1,4 @@
+/** In-memory cache adapter with time-based expiration. Used as the default result cache. */
 export class MemoryCacheAdapter {
     #data = new Map();
     #options;

package/cache/NullCacheAdapter.d.ts

@@ -1,4 +1,5 @@
 import type { SyncCacheAdapter } from './CacheAdapter.js';
+/** No-op cache adapter that never stores or returns any data. Used to disable caching. */
 export declare class NullCacheAdapter implements SyncCacheAdapter {
     /**
      * @inheritDoc

package/cache/NullCacheAdapter.js

@@ -1,3 +1,4 @@
+/** No-op cache adapter that never stores or returns any data. Used to disable caching. */
 export class NullCacheAdapter {
     /**
      * @inheritDoc

package/connections/Connection.d.ts

@@ -5,6 +5,7 @@ import type { ConnectionType, Dictionary, MaybePromise, Primary } from '../typin
 import type { Platform } from '../platforms/Platform.js';
 import type { TransactionEventBroadcaster } from '../events/TransactionEventBroadcaster.js';
 import type { IsolationLevel } from '../enums.js';
+/** Abstract base class for database connections, providing transaction and query execution support. */
 export declare abstract class Connection {
     #private;
     protected readonly config: Configuration;
@@ -49,6 +50,7 @@ export declare abstract class Connection {
      */
     executeDump(dump: string): Promise<void>;
     protected onConnect(): Promise<void>;
+    /** Executes a callback inside a transaction, committing on success and rolling back on failure. */
     transactional<T>(cb: (trx: Transaction) => Promise<T>, options?: {
         isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
@@ -56,6 +58,7 @@ export declare abstract class Connection {
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<T>;
+    /** Begins a new database transaction and returns the transaction context. */
     begin(options?: {
         isolationLevel?: IsolationLevel | `${IsolationLevel}`;
         readOnly?: boolean;
@@ -63,16 +66,24 @@ export declare abstract class Connection {
         eventBroadcaster?: TransactionEventBroadcaster;
         loggerContext?: LogContext;
     }): Promise<Transaction>;
+    /** Commits the given transaction. */
     commit(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    /** Rolls back the given transaction. */
     rollback(ctx: Transaction, eventBroadcaster?: TransactionEventBroadcaster, loggerContext?: LogContext): Promise<void>;
+    /** Executes a raw query and returns the result. */
     abstract execute<T>(query: string, params?: any[], method?: 'all' | 'get' | 'run', ctx?: Transaction): Promise<QueryResult<T> | any | any[]>;
+    /** Parses and returns the resolved connection configuration (host, port, user, etc.). */
     getConnectionOptions(): ConnectionConfig;
+    /** Sets the metadata storage on this connection. */
     setMetadata(metadata: MetadataStorage): void;
+    /** Sets the platform abstraction on this connection. */
     setPlatform(platform: Platform): void;
+    /** Returns the platform abstraction for this connection. */
     getPlatform(): Platform;
     protected executeQuery<T>(query: string, cb: () => Promise<T>, context?: LogContext): Promise<T>;
     protected logQuery(query: string, context?: LogContext): void;
 }
+/** Result of a native database query (insert, update, delete). */
 export interface QueryResult<T = {
     id: number;
 }> {
@@ -82,6 +93,7 @@ export interface QueryResult<T = {
     rows?: Dictionary[];
     insertedIds?: Primary<T>[];
 }
+/** Resolved database connection parameters. */
 export interface ConnectionConfig {
     host?: string;
     port?: number;
@@ -90,4 +102,5 @@ export interface ConnectionConfig {
     database?: string;
     schema?: string;
 }
+/** Opaque transaction context type, wrapping the driver-specific transaction object. */
 export type Transaction<T = any> = T & {};

package/connections/Connection.js

@@ -1,4 +1,5 @@
 import { Utils } from '../utils/Utils.js';
+/** Abstract base class for database connections, providing transaction and query execution support. */
 export class Connection {
     config;
     type;
@@ -75,18 +76,23 @@ export class Connection {
             }
         }
     }
+    /** Executes a callback inside a transaction, committing on success and rolling back on failure. */
     async transactional(cb, options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
+    /** Begins a new database transaction and returns the transaction context. */
     async begin(options) {
         throw new Error(`Transactions are not supported by current driver`);
     }
+    /** Commits the given transaction. */
     async commit(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
+    /** Rolls back the given transaction. */
     async rollback(ctx, eventBroadcaster, loggerContext) {
         throw new Error(`Transactions are not supported by current driver`);
     }
+    /** Parses and returns the resolved connection configuration (host, port, user, etc.). */
     getConnectionOptions() {
         const ret = {};
         if (this.options.clientUrl) {
@@ -113,12 +119,15 @@ export class Connection {
         }
         return ret;
     }
+    /** Sets the metadata storage on this connection. */
     setMetadata(metadata) {
         this.metadata = metadata;
     }
+    /** Sets the platform abstraction on this connection. */
     setPlatform(platform) {
         this.platform = platform;
     }
+    /** Returns the platform abstraction for this connection. */
     getPlatform() {
         return this.platform;
     }

package/drivers/DatabaseDriver.d.ts

@@ -10,6 +10,7 @@ import type { Collection } from '../entity/Collection.js';
 import { EntityManager } from '../EntityManager.js';
 import { DriverException } from '../exceptions.js';
 import { MikroORM } from '../MikroORM.js';
+/** Abstract base class for all database drivers, implementing common driver logic. */
 export declare abstract class DatabaseDriver<C extends Connection> implements IDatabaseDriver<C> {
     readonly config: Configuration;
     protected readonly dependencies: string[];
@@ -28,24 +29,34 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
     abstract nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: DeleteOptions<T>): Promise<QueryResult<T>>;
     abstract count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    /** Creates a new EntityManager instance bound to this driver. */
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
     findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
     countVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: CountOptions<T, any>): Promise<number>;
     aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<any>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
+    /** Maps raw database result to entity data, converting column names to property names. */
     mapResult<T extends object>(result: EntityDictionary<T>, meta?: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
+    /** Opens the primary connection and all read replicas. */
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<C>;
+    /** Closes all connections and re-establishes them. */
     reconnect(options?: {
         skipOnConnect?: boolean;
     }): Promise<C>;
+    /** Returns the write connection or a random read replica. */
     getConnection(type?: ConnectionType): C;
+    /** Closes the primary connection and all read replicas. */
     close(force?: boolean): Promise<void>;
+    /** Returns the database platform abstraction for this driver. */
     getPlatform(): Platform;
+    /** Sets the metadata storage and initializes the comparator for all connections. */
     setMetadata(metadata: MetadataStorage): void;
+    /** Returns the metadata storage used by this driver. */
     getMetadata(): MetadataStorage;
+    /** Returns the names of native database dependencies required by this driver. */
     getDependencies(): string[];
     protected isPopulated<T extends object>(meta: EntityMetadata<T>, prop: EntityProperty<T>, hint: PopulateOptions<T>, name?: string): boolean;
     protected processCursorOptions<T extends object, P extends string>(meta: EntityMetadata<T>, options: FindOptions<T, P, any, any>, orderBy: OrderDefinition<T>): {
@@ -58,6 +69,7 @@ export declare abstract class DatabaseDriver<C extends Connection> implements ID
     protected inlineEmbeddables<T extends object>(meta: EntityMetadata<T>, data: T, where?: boolean): void;
     protected getPrimaryKeyFields<T>(meta: EntityMetadata<T>): string[];
     protected createReplicas(cb: (c: ConnectionOptions) => C): C[];
+    /** Acquires a pessimistic lock on the given entity. */
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     abstract stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
     /**

package/drivers/DatabaseDriver.js

@@ -11,6 +11,7 @@ import { helper } from '../entity/wrap.js';
 import { PolymorphicRef } from '../entity/PolymorphicRef.js';
 import { JsonType } from '../types/JsonType.js';
 import { MikroORM } from '../MikroORM.js';
+/** Abstract base class for all database drivers, implementing common driver logic. */
 export class DatabaseDriver {
     config;
     dependencies;
@@ -27,6 +28,7 @@ export class DatabaseDriver {
     async nativeUpdateMany(entityName, where, data, options) {
         throw new Error(`Batch updates are not supported by ${this.constructor.name} driver`);
     }
+    /** Creates a new EntityManager instance bound to this driver. */
     createEntityManager(useContext) {
         const EntityManagerClass = this.config.get('entityManager', EntityManager);
         return new EntityManagerClass(this.config, this, this.metadata, useContext);
@@ -62,22 +64,26 @@ export class DatabaseDriver {
             }
         }
     }
+    /** Maps raw database result to entity data, converting column names to property names. */
     mapResult(result, meta, populate = []) {
         if (!result || !meta) {
             return result ?? null;
         }
         return this.comparator.mapResult(meta, result);
     }
+    /** Opens the primary connection and all read replicas. */
     async connect(options) {
         await this.connection.connect(options);
         await Promise.all(this.replicas.map(replica => replica.connect()));
         return this.connection;
     }
+    /** Closes all connections and re-establishes them. */
     async reconnect(options) {
         await this.close(true);
         await this.connect(options);
         return this.connection;
     }
+    /** Returns the write connection or a random read replica. */
     getConnection(type = 'write') {
         if (type === 'write' || this.replicas.length === 0) {
             return this.connection;
@@ -85,13 +91,16 @@ export class DatabaseDriver {
         const rand = Utils.randomInt(0, this.replicas.length - 1);
         return this.replicas[rand];
     }
+    /** Closes the primary connection and all read replicas. */
     async close(force) {
         await Promise.all(this.replicas.map(replica => replica.close(force)));
         await this.connection.close(force);
     }
+    /** Returns the database platform abstraction for this driver. */
     getPlatform() {
         return this.platform;
     }
+    /** Sets the metadata storage and initializes the comparator for all connections. */
     setMetadata(metadata) {
         this.metadata = metadata;
         this.comparator = new EntityComparator(this.metadata, this.platform);
@@ -102,9 +111,11 @@ export class DatabaseDriver {
             replica.setPlatform(this.platform);
         });
     }
+    /** Returns the metadata storage used by this driver. */
     getMetadata() {
         return this.metadata;
     }
+    /** Returns the names of native database dependencies required by this driver. */
     getDependencies() {
         return this.dependencies;
     }
@@ -426,6 +437,7 @@ export class DatabaseDriver {
         }
         return ret;
     }
+    /** Acquires a pessimistic lock on the given entity. */
     async lockPessimistic(entity, options) {
         throw new Error(`Pessimistic locks are not supported by ${this.constructor.name} driver`);
     }

package/drivers/IDatabaseDriver.d.ts

@@ -10,18 +10,25 @@ import type { Configuration } from '../utils/Configuration.js';
 import type { MikroORM } from '../MikroORM.js';
 import type { LoggingOptions, LogContext } from '../logging/Logger.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
+/** Symbol used to extract the EntityManager type from a driver instance. */
 export declare const EntityManagerType: unique symbol;
+/** Interface defining the contract for all database drivers. */
 export interface IDatabaseDriver<C extends Connection = Connection> {
     [EntityManagerType]: EntityManager<this>;
     readonly config: Configuration;
+    /** Creates a new EntityManager instance for this driver. */
     createEntityManager(useContext?: boolean): this[typeof EntityManagerType];
+    /** Opens a connection to the database. */
     connect(options?: {
         skipOnConnect?: boolean;
     }): Promise<C>;
+    /** Closes the database connection. */
     close(force?: boolean): Promise<void>;
+    /** Closes and re-establishes the database connection. */
     reconnect(options?: {
         skipOnConnect?: boolean;
     }): Promise<C>;
+    /** Returns the underlying database connection (write or read replica). */
     getConnection(type?: ConnectionType): C;
     /**
      * Finds selection of entities
@@ -31,29 +38,44 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      * Finds single entity (table row, document)
      */
     findOne<T extends object, P extends string = never, F extends string = '*', E extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: FindOneOptions<T, P, F, E>): Promise<EntityData<T> | null>;
+    /** Finds entities backed by a virtual (expression-based) definition. */
     findVirtual<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: FindOptions<T, any, any, any>): Promise<EntityData<T>[]>;
+    /** Returns an async iterator that streams query results one entity at a time. */
     stream<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options: StreamOptions<T>): AsyncIterableIterator<T>;
+    /** Inserts a single row into the database. */
     nativeInsert<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    /** Inserts multiple rows into the database in a single batch operation. */
     nativeInsertMany<T extends object>(entityName: EntityName<T>, data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>, transform?: (sql: string) => string): Promise<QueryResult<T>>;
+    /** Updates rows matching the given condition. */
     nativeUpdate<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, data: EntityDictionary<T>, options?: NativeInsertUpdateOptions<T>): Promise<QueryResult<T>>;
+    /** Updates multiple rows with different payloads in a single batch operation. */
     nativeUpdateMany<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>[], data: EntityDictionary<T>[], options?: NativeInsertUpdateManyOptions<T>): Promise<QueryResult<T>>;
+    /** Deletes rows matching the given condition. */
     nativeDelete<T extends object>(entityName: EntityName<T>, where: FilterQuery<T>, options?: NativeDeleteOptions<T>): Promise<QueryResult<T>>;
+    /** Persists changes to M:N collections (inserts/deletes pivot table rows). */
     syncCollections<T extends object, O extends object>(collections: Iterable<Collection<T, O>>, options?: DriverMethodOptions): Promise<void>;
+    /** Counts entities matching the given condition. */
     count<T extends object, P extends string = never>(entityName: EntityName<T>, where: FilterQuery<T>, options?: CountOptions<T, P>): Promise<number>;
+    /** Executes a MongoDB aggregation pipeline (MongoDB driver only). */
     aggregate(entityName: EntityName, pipeline: any[]): Promise<any[]>;
+    /** Maps raw database result to entity data, converting column names to property names. */
     mapResult<T extends object>(result: EntityDictionary<T>, meta: EntityMetadata<T>, populate?: PopulateOptions<T>[]): EntityData<T> | null;
     /**
      * When driver uses pivot tables for M:N, this method will load identifiers for given collections from them
      */
     loadFromPivotTable<T extends object, O extends object>(prop: EntityProperty, owners: Primary<O>[][], where?: FilterQuery<T>, orderBy?: OrderDefinition<T>, ctx?: Transaction, options?: FindOptions<T, any, any, any>, pivotJoin?: boolean): Promise<Dictionary<T[]>>;
+    /** Returns the database platform abstraction for this driver. */
     getPlatform(): Platform;
+    /** Sets the metadata storage used by this driver. */
     setMetadata(metadata: MetadataStorage): void;
+    /** Returns the metadata storage used by this driver. */
     getMetadata(): MetadataStorage;
     /**
      * Returns name of the underlying database dependencies (e.g. `mongodb` or `mysql2`)
      * for SQL drivers it also returns `knex` in the array as connectors are not used directly there
      */
     getDependencies(): string[];
+    /** Acquires a pessimistic lock on the given entity. */
     lockPessimistic<T extends object>(entity: T, options: LockOptions): Promise<void>;
     /**
      * Converts native db errors to standardized driver exceptions
@@ -71,13 +93,17 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
      */
     getORMClass(): Constructor<MikroORM>;
 }
+/** Represents a field selector for entity queries (property name or wildcard). */
 export type EntityField<T, P extends string = PopulatePath.ALL> = keyof T | PopulatePath.ALL | AutoPath<T, P, `${PopulatePath.ALL}`>;
+/** Defines the ordering for query results, either a single order map or an array of them. */
 export type OrderDefinition<T> = (QueryOrderMap<T> & {
     0?: never;
 }) | QueryOrderMap<T>[];
+/** Options for `em.findAll()`, extends FindOptions with an optional `where` clause. */
 export interface FindAllOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends FindOptions<T, P, F, E> {
     where?: FilterQuery<T>;
 }
+/** Options for streaming query results via `em.stream()`. */
 export interface StreamOptions<Entity, Populate extends string = never, Fields extends string = '*', Exclude extends string = never> extends Omit<FindAllOptions<Entity, Populate, Fields, Exclude>, 'cache' | 'before' | 'after' | 'first' | 'last' | 'overfetch' | 'strategy'> {
     /**
      * When populating to-many relations, the ORM streams fully merged entities instead of yielding every row.
@@ -90,12 +116,15 @@ export interface StreamOptions<Entity, Populate extends string = never, Fields e
      */
     mergeResults?: boolean;
 }
+/** Configuration for enabling/disabling named filters on a query. */
 export type FilterOptions = Dictionary<boolean | Dictionary> | string[] | boolean;
+/** Specifies which relations to populate and which fields to select or exclude. */
 export interface LoadHint<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
     populate?: Populate<Entity, Hint>;
     fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
     exclude?: readonly AutoPath<Entity, Excludes>[];
 }
+/** Options for `em.find()` queries, including population, ordering, pagination, and locking. */
 export interface FindOptions<Entity, Hint extends string = never, Fields extends string = PopulatePath.ALL, Excludes extends string = never> extends LoadHint<Entity, Hint, Fields, Excludes> {
     /**
      * Where condition for populated relations. This will have no effect on the root entity.
@@ -197,17 +226,21 @@ export interface FindOptions<Entity, Hint extends string = never, Fields extends
     /** @internal used to apply filters to the auto-joined relations */
     em?: EntityManager;
 }
+/** Options for cursor-based pagination via `em.findByCursor()`. */
 export interface FindByCursorOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never, I extends boolean = true> extends Omit<FindAllOptions<T, P, F, E>, 'limit' | 'offset'> {
     includeCount?: I;
 }
+/** Options for `em.findOne()`, extends FindOptions with optimistic lock version support. */
 export interface FindOneOptions<T, P extends string = never, F extends string = '*', E extends string = never> extends Omit<FindOptions<T, P, F, E>, 'limit' | 'lockMode'> {
     lockMode?: LockMode;
     lockVersion?: number | Date;
 }
+/** Options for `em.findOneOrFail()`, adds a custom error handler for missing entities. */
 export interface FindOneOrFailOptions<T extends object, P extends string = never, F extends string = '*', E extends string = never> extends FindOneOptions<T, P, F, E> {
     failHandler?: (entityName: string, where: Dictionary | IPrimaryKey | any) => Error;
     strict?: boolean;
 }
+/** Options for native insert and update operations. */
 export interface NativeInsertUpdateOptions<T> {
     convertCustomTypes?: boolean;
     ctx?: Transaction;
@@ -223,9 +256,11 @@ export interface NativeInsertUpdateOptions<T> {
     /** @internal */
     em?: EntityManager;
 }
+/** Options for batch native insert and update operations. */
 export interface NativeInsertUpdateManyOptions<T> extends NativeInsertUpdateOptions<T> {
     processCollections?: boolean;
 }
+/** Options for `em.upsert()`, controlling conflict resolution behavior. */
 export interface UpsertOptions<Entity, Fields extends string = never> extends Omit<NativeInsertUpdateOptions<Entity>, 'upsert'> {
     onConflictFields?: (keyof Entity)[] | Raw;
     onConflictAction?: 'ignore' | 'merge';
@@ -234,9 +269,11 @@ export interface UpsertOptions<Entity, Fields extends string = never> extends Om
     onConflictWhere?: FilterQuery<Entity>;
     disableIdentityMap?: boolean;
 }
+/** Options for `em.upsertMany()`, adds batch size control. */
 export interface UpsertManyOptions<Entity, Fields extends string = never> extends UpsertOptions<Entity, Fields> {
     batchSize?: number;
 }
+/** Options for `em.count()` queries. */
 export interface CountOptions<T extends object, P extends string = never> {
     filters?: FilterOptions;
     schema?: string;
@@ -268,6 +305,7 @@ export interface CountOptions<T extends object, P extends string = never> {
     /** @internal used to apply filters to the auto-joined relations */
     em?: EntityManager;
 }
+/** Options for `em.qb().update()` operations. */
 export interface UpdateOptions<T> {
     filters?: FilterOptions;
     schema?: string;
@@ -277,6 +315,7 @@ export interface UpdateOptions<T> {
     /** sql only */
     unionWhereStrategy?: 'union-all' | 'union';
 }
+/** Options for `em.qb().delete()` operations. */
 export interface DeleteOptions<T> extends DriverMethodOptions {
     filters?: FilterOptions;
     /** sql only */
@@ -286,6 +325,7 @@ export interface DeleteOptions<T> extends DriverMethodOptions {
     /** @internal */
     em?: EntityManager;
 }
+/** Options for `em.nativeDelete()` operations. */
 export interface NativeDeleteOptions<T> extends DriverMethodOptions {
     filters?: FilterOptions;
     /** sql only */
@@ -295,17 +335,20 @@ export interface NativeDeleteOptions<T> extends DriverMethodOptions {
     /** @internal */
     em?: EntityManager;
 }
+/** Options for pessimistic and optimistic lock operations. */
 export interface LockOptions extends DriverMethodOptions {
     lockMode?: LockMode;
     lockVersion?: number | Date;
     lockTableAliases?: string[];
     logging?: LoggingOptions;
 }
+/** Base options shared by all driver methods (transaction context, schema, logging). */
 export interface DriverMethodOptions {
     ctx?: Transaction;
     schema?: string;
     loggerContext?: LogContext;
 }
+/** MongoDB-style collation options for locale-aware string comparison. */
 export interface CollationOptions {
     locale: string;
     caseLevel?: boolean;
@@ -316,6 +359,7 @@ export interface CollationOptions {
     maxVariable?: string;
     backwards?: boolean;
 }
+/** Options for `em.getReference()`, controlling wrapping and type conversion. */
 export interface GetReferenceOptions {
     wrapped?: boolean;
     convertCustomTypes?: boolean;

package/drivers/IDatabaseDriver.js

@@ -1 +1,2 @@
+/** Symbol used to extract the EntityManager type from a driver instance. */
 export const EntityManagerType = Symbol('EntityManagerType');

package/entity/BaseEntity.d.ts

@@ -5,10 +5,15 @@ import type { EntityLoaderOptions } from './EntityLoader.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions } from '../drivers/IDatabaseDriver.js';
 import type { PopulatePath } from '../enums.js';
+/** Base class for entities providing convenience methods like `assign()`, `toObject()`, and `populate()`. */
 export declare abstract class BaseEntity {
+    /** Returns whether the entity has been fully loaded from the database. */
     isInitialized(): boolean;
+    /** Marks the entity as populated or not for serialization purposes. */
     populated(populated?: boolean): void;
+    /** Loads the specified relations on this entity. */
     populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
+    /** Returns a Reference wrapper for this entity. */
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     /**
      * Converts the entity to a plain object representation.
@@ -72,10 +77,16 @@ export declare abstract class BaseEntity {
      * @param ignoreFields - Array of field names to omit from the result.
      */
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
+    /** Converts the entity to a plain object, including all properties regardless of serialization rules. */
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
+    /** Serializes the entity with control over which relations and fields to include or exclude. */
     serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
+    /** Assigns the given data to this entity, updating its properties and relations. */
     assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
+    /** Initializes (refreshes) the entity by reloading it from the database. Returns null if not found. */
     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>;
+    /** Returns the database schema this entity belongs to. */
     getSchema(): string | undefined;
+    /** Sets the database schema for this entity. */
     setSchema(schema?: string): void;
 }