@mikro-orm/core 7.0.2-dev.13 → 7.0.2-dev.15

package/enums.js

@@ -1,3 +1,4 @@
+/** Controls when the `EntityManager` flushes pending changes to the database. */
 export var FlushMode;
 (function (FlushMode) {
     /** The `EntityManager` delays the flush until the current Transaction is committed. */
@@ -7,84 +8,148 @@ export var FlushMode;
     /** Flushes the `EntityManager` before every query. */
     FlushMode["ALWAYS"] = "always";
 })(FlushMode || (FlushMode = {}));
+/** Controls how populate hints are resolved when using `FindOptions.populateWhere`. */
 export var PopulateHint;
 (function (PopulateHint) {
+    /** Infer population hints from the `where` condition. */
     PopulateHint["INFER"] = "infer";
+    /** Apply population hints to all relations. */
     PopulateHint["ALL"] = "all";
 })(PopulateHint || (PopulateHint = {}));
+/** Special tokens used as populate path values in `FindOptions.populate`. */
 export var PopulatePath;
 (function (PopulatePath) {
+    /** Infer which relations to populate based on fields accessed in the `where` or `orderBy` clause. */
     PopulatePath["INFER"] = "$infer";
+    /** Populate all relations. */
     PopulatePath["ALL"] = "*";
 })(PopulatePath || (PopulatePath = {}));
+/** Logical grouping operators for combining query conditions. */
 export var GroupOperator;
 (function (GroupOperator) {
+    /** Logical AND — all conditions must match. */
     GroupOperator["$and"] = "and";
+    /** Logical OR — at least one condition must match. */
     GroupOperator["$or"] = "or";
 })(GroupOperator || (GroupOperator = {}));
+/** Comparison and filtering operators used in query conditions. */
 export var QueryOperator;
 (function (QueryOperator) {
+    /** Equal. */
     QueryOperator["$eq"] = "=";
+    /** Included in the given list. */
     QueryOperator["$in"] = "in";
+    /** Not included in the given list. */
     QueryOperator["$nin"] = "not in";
+    /** Greater than. */
     QueryOperator["$gt"] = ">";
+    /** Greater than or equal to. */
     QueryOperator["$gte"] = ">=";
+    /** Less than. */
     QueryOperator["$lt"] = "<";
+    /** Less than or equal to. */
     QueryOperator["$lte"] = "<=";
+    /** Not equal. */
     QueryOperator["$ne"] = "!=";
+    /** Negation wrapper. */
     QueryOperator["$not"] = "not";
+    /** SQL LIKE pattern matching. */
     QueryOperator["$like"] = "like";
+    /** Regular expression matching. */
     QueryOperator["$re"] = "regexp";
+    /** Full-text search. */
     QueryOperator["$fulltext"] = "fulltext";
+    /** Checks that the value is not null (i.e., exists). */
     QueryOperator["$exists"] = "not null";
+    /** Case-insensitive LIKE (PostgreSQL only). */
     QueryOperator["$ilike"] = "ilike";
+    /** Array overlap operator (PostgreSQL only). */
     QueryOperator["$overlap"] = "&&";
+    /** Array/JSON contains operator (PostgreSQL only). */
     QueryOperator["$contains"] = "@>";
+    /** Array/JSON contained-by operator (PostgreSQL only). */
     QueryOperator["$contained"] = "<@";
+    /** No element in the collection matches (SQL only). */
     QueryOperator["$none"] = "none";
+    /** At least one element in the collection matches (SQL only). */
     QueryOperator["$some"] = "some";
+    /** Every element in the collection matches (SQL only). */
     QueryOperator["$every"] = "every";
+    /** Matches collections by their size (SQL only). */
     QueryOperator["$size"] = "size";
+    /** JSON object has the given key (PostgreSQL only). */
     QueryOperator["$hasKey"] = "?";
+    /** JSON object has all of the given keys (PostgreSQL only). */
     QueryOperator["$hasKeys"] = "?&";
+    /** JSON object has at least one of the given keys (PostgreSQL only). */
     QueryOperator["$hasSomeKeys"] = "?|";
+    /** Matches an element inside a JSON array (SQL only). */
     QueryOperator["$elemMatch"] = "elemMatch";
 })(QueryOperator || (QueryOperator = {}));
 export const ARRAY_OPERATORS = ['$eq', '$gt', '$gte', '$lt', '$lte', '$ne', '$overlap', '$contains', '$contained'];
 export const JSON_KEY_OPERATORS = ['$hasKey', '$hasKeys', '$hasSomeKeys'];
+/** Sort direction for query results. Both upper- and lower-case variants are accepted. */
 export var QueryOrder;
 (function (QueryOrder) {
+    /** Ascending order. */
     QueryOrder["ASC"] = "ASC";
+    /** Ascending order with nulls sorted last. */
     QueryOrder["ASC_NULLS_LAST"] = "ASC NULLS LAST";
+    /** Ascending order with nulls sorted first. */
     QueryOrder["ASC_NULLS_FIRST"] = "ASC NULLS FIRST";
+    /** Descending order. */
     QueryOrder["DESC"] = "DESC";
+    /** Descending order with nulls sorted last. */
     QueryOrder["DESC_NULLS_LAST"] = "DESC NULLS LAST";
+    /** Descending order with nulls sorted first. */
     QueryOrder["DESC_NULLS_FIRST"] = "DESC NULLS FIRST";
+    /** Ascending order (lower-case variant). */
     QueryOrder["asc"] = "asc";
+    /** Ascending order with nulls sorted last (lower-case variant). */
     QueryOrder["asc_nulls_last"] = "asc nulls last";
+    /** Ascending order with nulls sorted first (lower-case variant). */
     QueryOrder["asc_nulls_first"] = "asc nulls first";
+    /** Descending order (lower-case variant). */
     QueryOrder["desc"] = "desc";
+    /** Descending order with nulls sorted last (lower-case variant). */
     QueryOrder["desc_nulls_last"] = "desc nulls last";
+    /** Descending order with nulls sorted first (lower-case variant). */
     QueryOrder["desc_nulls_first"] = "desc nulls first";
 })(QueryOrder || (QueryOrder = {}));
+/** Numeric sort direction, compatible with MongoDB-style ordering. */
 export var QueryOrderNumeric;
 (function (QueryOrderNumeric) {
+    /** Ascending order. */
     QueryOrderNumeric[QueryOrderNumeric["ASC"] = 1] = "ASC";
+    /** Descending order. */
     QueryOrderNumeric[QueryOrderNumeric["DESC"] = -1] = "DESC";
 })(QueryOrderNumeric || (QueryOrderNumeric = {}));
+/** Flags that modify query builder behavior. */
 export var QueryFlag;
 (function (QueryFlag) {
+    /** Add a DISTINCT clause to the SELECT statement. */
     QueryFlag["DISTINCT"] = "DISTINCT";
+    /** Enable result pagination via a sub-query for the primary keys. */
     QueryFlag["PAGINATE"] = "PAGINATE";
+    /** Disable the automatic pagination sub-query. */
     QueryFlag["DISABLE_PAGINATE"] = "DISABLE_PAGINATE";
+    /** Wrap UPDATE statements in a sub-query. */
     QueryFlag["UPDATE_SUB_QUERY"] = "UPDATE_SUB_QUERY";
+    /** Wrap DELETE statements in a sub-query. */
     QueryFlag["DELETE_SUB_QUERY"] = "DELETE_SUB_QUERY";
+    /** Convert values through custom type mappings when reading results. */
     QueryFlag["CONVERT_CUSTOM_TYPES"] = "CONVERT_CUSTOM_TYPES";
+    /** Include lazy formula properties in the SELECT clause. */
     QueryFlag["INCLUDE_LAZY_FORMULAS"] = "INCLUDE_LAZY_FORMULAS";
+    /** Automatically join the owning side of one-to-one relations. */
     QueryFlag["AUTO_JOIN_ONE_TO_ONE_OWNER"] = "AUTO_JOIN_ONE_TO_ONE_OWNER";
+    /** Infer the populate hint from the query fields. */
     QueryFlag["INFER_POPULATE"] = "INFER_POPULATE";
+    /** Prevent nested conditions from being promoted to INNER JOINs. */
     QueryFlag["DISABLE_NESTED_INNER_JOIN"] = "DISABLE_NESTED_INNER_JOIN";
+    /** Enable IDENTITY_INSERT for explicit PK values (MSSQL only). */
     QueryFlag["IDENTITY_INSERT"] = "IDENTITY_INSERT";
+    /** Use an OUTPUT...INTO temp table for returning rows (MSSQL only). */
     QueryFlag["OUTPUT_TABLE"] = "OUTPUT_TABLE";
 })(QueryFlag || (QueryFlag = {}));
 export const SCALAR_TYPES = new Set([
@@ -97,98 +162,165 @@ export const SCALAR_TYPES = new Set([
     'Buffer',
     'RegExp',
 ]);
+/** Describes the kind of relationship a property represents. */
 export var ReferenceKind;
 (function (ReferenceKind) {
+    /** A plain scalar property (not a relation). */
     ReferenceKind["SCALAR"] = "scalar";
+    /** A one-to-one relation. */
     ReferenceKind["ONE_TO_ONE"] = "1:1";
+    /** A one-to-many relation (inverse side of a many-to-one). */
     ReferenceKind["ONE_TO_MANY"] = "1:m";
+    /** A many-to-one relation (owning side). */
     ReferenceKind["MANY_TO_ONE"] = "m:1";
+    /** A many-to-many relation. */
     ReferenceKind["MANY_TO_MANY"] = "m:n";
+    /** An embedded entity (inline object stored within the parent). */
     ReferenceKind["EMBEDDED"] = "embedded";
 })(ReferenceKind || (ReferenceKind = {}));
+/** Cascade operations that propagate from a parent entity to its relations. */
 export var Cascade;
 (function (Cascade) {
+    /** Cascade persist — new related entities are automatically persisted. */
     Cascade["PERSIST"] = "persist";
+    /** Cascade merge — detached related entities are merged into the identity map. */
     Cascade["MERGE"] = "merge";
+    /** Cascade remove — removing the parent also removes related entities. */
     Cascade["REMOVE"] = "remove";
+    /** Enable all cascade operations (persist, merge, remove). */
     Cascade["ALL"] = "all";
     /** @internal */
     Cascade["SCHEDULE_ORPHAN_REMOVAL"] = "schedule_orphan_removal";
     /** @internal */
     Cascade["CANCEL_ORPHAN_REMOVAL"] = "cancel_orphan_removal";
 })(Cascade || (Cascade = {}));
+/** Strategy used to load related entities when populating. */
 export var LoadStrategy;
 (function (LoadStrategy) {
+    /** Load relations with a separate SELECT ... WHERE pk IN (...) query. */
     LoadStrategy["SELECT_IN"] = "select-in";
+    /** Load relations via SQL JOINs in a single query. */
     LoadStrategy["JOINED"] = "joined";
+    /** Use joined strategy for to-one relations and select-in for to-many. */
     LoadStrategy["BALANCED"] = "balanced";
 })(LoadStrategy || (LoadStrategy = {}));
+/** Controls which relation types use the dataloader for batched loading. */
 export var DataloaderType;
 (function (DataloaderType) {
+    /** Dataloader is disabled. */
     DataloaderType[DataloaderType["NONE"] = 0] = "NONE";
+    /** Use the dataloader for Reference (to-one) relations only. */
     DataloaderType[DataloaderType["REFERENCE"] = 1] = "REFERENCE";
+    /** Use the dataloader for Collection (to-many) relations only. */
     DataloaderType[DataloaderType["COLLECTION"] = 2] = "COLLECTION";
+    /** Use the dataloader for both Reference and Collection relations. */
     DataloaderType[DataloaderType["ALL"] = 3] = "ALL";
 })(DataloaderType || (DataloaderType = {}));
+/** Locking strategy for concurrency control. */
 export var LockMode;
 (function (LockMode) {
+    /** No locking. */
     LockMode[LockMode["NONE"] = 0] = "NONE";
+    /** Optimistic locking via a version column. */
     LockMode[LockMode["OPTIMISTIC"] = 1] = "OPTIMISTIC";
+    /** Pessimistic shared lock (FOR SHARE). */
     LockMode[LockMode["PESSIMISTIC_READ"] = 2] = "PESSIMISTIC_READ";
+    /** Pessimistic exclusive lock (FOR UPDATE). */
     LockMode[LockMode["PESSIMISTIC_WRITE"] = 3] = "PESSIMISTIC_WRITE";
+    /** Pessimistic exclusive lock that skips already-locked rows (FOR UPDATE SKIP LOCKED). */
     LockMode[LockMode["PESSIMISTIC_PARTIAL_WRITE"] = 4] = "PESSIMISTIC_PARTIAL_WRITE";
+    /** Pessimistic exclusive lock that fails immediately if the row is locked (FOR UPDATE NOWAIT). */
     LockMode[LockMode["PESSIMISTIC_WRITE_OR_FAIL"] = 5] = "PESSIMISTIC_WRITE_OR_FAIL";
+    /** Pessimistic shared lock that skips already-locked rows (FOR SHARE SKIP LOCKED). */
     LockMode[LockMode["PESSIMISTIC_PARTIAL_READ"] = 6] = "PESSIMISTIC_PARTIAL_READ";
+    /** Pessimistic shared lock that fails immediately if the row is locked (FOR SHARE NOWAIT). */
     LockMode[LockMode["PESSIMISTIC_READ_OR_FAIL"] = 7] = "PESSIMISTIC_READ_OR_FAIL";
 })(LockMode || (LockMode = {}));
+/** Transaction isolation levels as defined by the SQL standard (plus vendor extensions). */
 export var IsolationLevel;
 (function (IsolationLevel) {
+    /** Allows dirty reads, non-repeatable reads, and phantom reads. */
     IsolationLevel["READ_UNCOMMITTED"] = "read uncommitted";
+    /** Prevents dirty reads; non-repeatable and phantom reads are still possible. */
     IsolationLevel["READ_COMMITTED"] = "read committed";
+    /** Snapshot isolation — each transaction sees a consistent snapshot of the database (MSSQL). */
     IsolationLevel["SNAPSHOT"] = "snapshot";
+    /** Prevents dirty and non-repeatable reads; phantom reads are still possible. */
     IsolationLevel["REPEATABLE_READ"] = "repeatable read";
+    /** Full isolation — transactions are executed as if they were run sequentially. */
     IsolationLevel["SERIALIZABLE"] = "serializable";
 })(IsolationLevel || (IsolationLevel = {}));
+/** Lifecycle and transaction events emitted by the ORM. */
 export var EventType;
 (function (EventType) {
+    /** Fired when an entity instance is created (via constructor or `em.create`). */
     EventType["onInit"] = "onInit";
+    /** Fired after an entity is loaded from the database. */
     EventType["onLoad"] = "onLoad";
+    /** Fired before a new entity is inserted into the database. */
     EventType["beforeCreate"] = "beforeCreate";
+    /** Fired after a new entity has been inserted into the database. */
     EventType["afterCreate"] = "afterCreate";
+    /** Fired before an existing entity is updated in the database. */
     EventType["beforeUpdate"] = "beforeUpdate";
+    /** Fired after an existing entity has been updated in the database. */
     EventType["afterUpdate"] = "afterUpdate";
+    /** Fired before an upsert operation. */
     EventType["beforeUpsert"] = "beforeUpsert";
+    /** Fired after an upsert operation. */
     EventType["afterUpsert"] = "afterUpsert";
+    /** Fired before an entity is deleted from the database. */
     EventType["beforeDelete"] = "beforeDelete";
+    /** Fired after an entity has been deleted from the database. */
     EventType["afterDelete"] = "afterDelete";
+    /** Fired at the very beginning of `em.flush()`, before change detection. */
     EventType["beforeFlush"] = "beforeFlush";
+    /** Fired during `em.flush()` after change detection but before database writes. */
     EventType["onFlush"] = "onFlush";
+    /** Fired after `em.flush()` has completed all database writes. */
     EventType["afterFlush"] = "afterFlush";
+    /** Fired before a new database transaction is started. */
     EventType["beforeTransactionStart"] = "beforeTransactionStart";
+    /** Fired after a new database transaction has been started. */
     EventType["afterTransactionStart"] = "afterTransactionStart";
+    /** Fired before a database transaction is committed. */
     EventType["beforeTransactionCommit"] = "beforeTransactionCommit";
+    /** Fired after a database transaction has been committed. */
     EventType["afterTransactionCommit"] = "afterTransactionCommit";
+    /** Fired before a database transaction is rolled back. */
     EventType["beforeTransactionRollback"] = "beforeTransactionRollback";
+    /** Fired after a database transaction has been rolled back. */
     EventType["afterTransactionRollback"] = "afterTransactionRollback";
 })(EventType || (EventType = {}));
 export const EventTypeMap = Object.keys(EventType).reduce((a, b, i) => {
     a[b] = i;
     return a;
 }, {});
+/** Controls how a transactional operation interacts with an existing transaction. */
 export var TransactionPropagation;
 (function (TransactionPropagation) {
+    /** Join the current transaction or create a new one if none exists. */
     TransactionPropagation["REQUIRED"] = "required";
+    /** Always create a new transaction, suspending the current one if it exists. */
     TransactionPropagation["REQUIRES_NEW"] = "requires_new";
+    /** Create a nested savepoint within the current transaction, or a new transaction if none exists. */
     TransactionPropagation["NESTED"] = "nested";
+    /** Execute non-transactionally, suspending the current transaction if one exists. */
     TransactionPropagation["NOT_SUPPORTED"] = "not_supported";
+    /** Join the current transaction if one exists, otherwise execute non-transactionally. */
     TransactionPropagation["SUPPORTS"] = "supports";
+    /** Join the current transaction; throw if no transaction is active. */
     TransactionPropagation["MANDATORY"] = "mandatory";
+    /** Execute non-transactionally; throw if a transaction is active. */
     TransactionPropagation["NEVER"] = "never";
 })(TransactionPropagation || (TransactionPropagation = {}));
 export class PlainObject {
 }
+/** Constraint deferral mode for database constraints (e.g., foreign keys, unique). */
 export var DeferMode;
 (function (DeferMode) {
+    /** The constraint is checked immediately by default, but can be deferred within a transaction. */
     DeferMode["INITIALLY_IMMEDIATE"] = "immediate";
+    /** The constraint is deferred until the transaction is committed. */
     DeferMode["INITIALLY_DEFERRED"] = "deferred";
 })(DeferMode || (DeferMode = {}));

package/errors.d.ts

@@ -1,4 +1,5 @@
 import type { AnyEntity, Constructor, Dictionary, EntityMetadata, EntityName, EntityProperty, IPrimaryKey } from './typings.js';
+/** Base error class for ORM validation errors such as invalid entity state or incorrect usage. */
 export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Error {
     readonly entity?: T | undefined;
     constructor(message: string, entity?: T | undefined);
@@ -29,15 +30,18 @@ export declare class ValidationError<T extends AnyEntity = AnyEntity> extends Er
     static invalidEmbeddableQuery(entityName: EntityName, propName: string, embeddableType: string): ValidationError;
     static invalidQueryCondition(cond: unknown): ValidationError;
 }
+/** Error thrown when cursor-based pagination encounters missing or invalid cursor values. */
 export declare class CursorError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static entityNotPopulated(entity: AnyEntity, prop: string): ValidationError;
     static missingValue(entityName: string, prop: string): ValidationError;
 }
+/** Error thrown when an optimistic lock conflict is detected during entity persistence. */
 export declare class OptimisticLockError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static notVersioned(meta: EntityMetadata): OptimisticLockError;
     static lockFailed(entityOrName: AnyEntity | string): OptimisticLockError;
     static lockFailedVersionMismatch(entity: AnyEntity, expectedLockVersion: number | Date, actualLockVersion: number | Date): OptimisticLockError;
 }
+/** Error thrown when entity metadata is invalid, incomplete, or inconsistent. */
 export declare class MetadataError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static fromMissingPrimaryKey(meta: EntityMetadata): MetadataError;
     static fromWrongReference(meta: EntityMetadata, prop: EntityProperty, key: 'inversedBy' | 'mappedBy', owner?: EntityProperty): MetadataError;
@@ -72,11 +76,13 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;
     private static fromMessage;
 }
+/** Error thrown when an entity lookup fails to find the expected result. */
 export declare class NotFoundError<T extends AnyEntity = AnyEntity> extends ValidationError<T> {
     static findOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
     static findExactlyOneFailed(name: string, where: Dictionary | IPrimaryKey): NotFoundError;
     static failedToLoadProperty(name: string, propName: string, where: unknown): NotFoundError;
 }
+/** Error thrown when a transaction propagation requirement is not satisfied. */
 export declare class TransactionStateError extends ValidationError {
     static requiredTransactionNotFound(propagation: string): TransactionStateError;
     static transactionNotAllowed(propagation: string): TransactionStateError;

package/errors.js

@@ -1,5 +1,6 @@
 import { inspect } from './logging/inspect.js';
 import { Utils } from './utils/Utils.js';
+/** Base error class for ORM validation errors such as invalid entity state or incorrect usage. */
 export class ValidationError extends Error {
     entity;
     constructor(message, entity) {
@@ -107,6 +108,7 @@ export class ValidationError extends Error {
         return new ValidationError(`Invalid query condition: ${inspect(cond, { depth: 5 })}`);
     }
 }
+/** Error thrown when cursor-based pagination encounters missing or invalid cursor values. */
 export class CursorError extends ValidationError {
     static entityNotPopulated(entity, prop) {
         return new CursorError(`Cannot create cursor, value for '${entity.constructor.name}.${prop}' is missing.`);
@@ -115,6 +117,7 @@ export class CursorError extends ValidationError {
         return new CursorError(`Invalid cursor condition, value for '${entityName}.${prop}' is missing.`);
     }
 }
+/** Error thrown when an optimistic lock conflict is detected during entity persistence. */
 export class OptimisticLockError extends ValidationError {
     static notVersioned(meta) {
         return new OptimisticLockError(`Cannot obtain optimistic lock on unversioned entity ${meta.className}`);
@@ -130,6 +133,7 @@ export class OptimisticLockError extends ValidationError {
         return new OptimisticLockError(`The optimistic lock failed, version ${expectedLockVersion} was expected, but is actually ${actualLockVersion}`, entity);
     }
 }
+/** Error thrown when entity metadata is invalid, incomplete, or inconsistent. */
 export class MetadataError extends ValidationError {
     static fromMissingPrimaryKey(meta) {
         return new MetadataError(`${meta.className} entity is missing @PrimaryKey()`);
@@ -243,6 +247,7 @@ export class MetadataError extends ValidationError {
         return new MetadataError(`${meta.className}.${prop.name} ${message}`);
     }
 }
+/** Error thrown when an entity lookup fails to find the expected result. */
 export class NotFoundError extends ValidationError {
     static findOneFailed(name, where) {
         return new NotFoundError(`${name} not found (${inspect(where)})`);
@@ -255,6 +260,7 @@ export class NotFoundError extends ValidationError {
         return new NotFoundError(`${name} (${whereString}) failed to load property '${propName}'`);
     }
 }
+/** Error thrown when a transaction propagation requirement is not satisfied. */
 export class TransactionStateError extends ValidationError {
     static requiredTransactionNotFound(propagation) {
         return new TransactionStateError(`No existing transaction found for transaction marked with propagation "${propagation}"`);

package/events/EventManager.d.ts

@@ -1,15 +1,20 @@
 import type { EntityMetadata } from '../typings.js';
 import type { EventArgs, EventSubscriber, FlushEventArgs, TransactionEventArgs } from './EventSubscriber.js';
 import { EventType, type TransactionEventType } from '../enums.js';
+/** Manages event subscribers and dispatches entity/flush/transaction lifecycle events. */
 export declare class EventManager {
     #private;
     constructor(subscribers: Iterable<EventSubscriber>);
+    /** Registers an event subscriber and indexes its subscribed entities and event types. */
     registerSubscriber(subscriber: EventSubscriber): void;
+    /** Returns the set of all registered event subscribers. */
     getSubscribers(): Set<EventSubscriber>;
     dispatchEvent<T extends object>(event: TransactionEventType, args: TransactionEventArgs, meta?: EntityMetadata<T>): unknown;
     dispatchEvent<T extends object>(event: EventType.onInit, args: Partial<EventArgs<T>>, meta?: EntityMetadata<T>): unknown;
     dispatchEvent<T extends object>(event: EventType, args: Partial<EventArgs<T> | FlushEventArgs>, meta?: EntityMetadata<T>): Promise<unknown>;
+    /** Checks whether there are any listeners (hooks or subscribers) for the given event type and entity. */
     hasListeners<T>(event: EventType, meta: EntityMetadata<T>): boolean;
+    /** Creates a new EventManager with the same set of subscribers. */
     clone(): EventManager;
     private getSubscribedEntities;
 }

package/events/EventManager.js

@@ -1,5 +1,6 @@
 import { Utils } from '../utils/Utils.js';
 import { EventType, EventTypeMap } from '../enums.js';
+/** Manages event subscribers and dispatches entity/flush/transaction lifecycle events. */
 export class EventManager {
     #listeners = {};
     #entities = new Map();
@@ -10,6 +11,7 @@ export class EventManager {
             this.registerSubscriber(subscriber);
         }
     }
+    /** Registers an event subscriber and indexes its subscribed entities and event types. */
     registerSubscriber(subscriber) {
         if (this.#subscribers.has(subscriber)) {
             return;
@@ -24,6 +26,7 @@ export class EventManager {
             this.#listeners[event].add(subscriber);
         });
     }
+    /** Returns the set of all registered event subscribers. */
     getSubscribers() {
         return this.#subscribers;
     }
@@ -52,6 +55,7 @@ export class EventManager {
         }
         return Utils.runSerial(listeners, listener => listener(args));
     }
+    /** Checks whether there are any listeners (hooks or subscribers) for the given event type and entity. */
     hasListeners(event, meta) {
         const cacheKey = meta._id + EventTypeMap[event];
         if (this.#cache.has(cacheKey)) {
@@ -72,6 +76,7 @@ export class EventManager {
         this.#cache.set(cacheKey, false);
         return false;
     }
+    /** Creates a new EventManager with the same set of subscribers. */
     clone() {
         return new EventManager(this.#subscribers);
     }

package/events/EventSubscriber.d.ts

@@ -3,21 +3,25 @@ import type { EntityManager } from '../EntityManager.js';
 import type { UnitOfWork } from '../unit-of-work/UnitOfWork.js';
 import type { ChangeSet } from '../unit-of-work/ChangeSet.js';
 import type { Transaction } from '../connections/Connection.js';
+/** Arguments passed to entity lifecycle event hooks. */
 export interface EventArgs<T> {
     entity: T;
     em: EntityManager;
     meta: EntityMetadata<T>;
     changeSet?: ChangeSet<T & {}>;
 }
+/** Arguments passed to flush lifecycle event hooks (beforeFlush, onFlush, afterFlush). */
 export interface FlushEventArgs extends Omit<EventArgs<any>, 'entity' | 'changeSet' | 'meta'> {
     uow: UnitOfWork;
 }
+/** Arguments passed to transaction lifecycle event hooks (start, commit, rollback). */
 export interface TransactionEventArgs extends Omit<EventArgs<any>, 'entity' | 'meta' | 'changeSet'> {
     transaction?: Transaction & {
         savepointName?: string;
     };
     uow?: UnitOfWork;
 }
+/** Interface for subscribing to entity and transaction lifecycle events. */
 export interface EventSubscriber<T = any> {
     getSubscribedEntities?(): EntityName<T>[];
     onInit?(args: EventArgs<T>): void;

package/events/TransactionEventBroadcaster.d.ts

@@ -1,6 +1,7 @@
 import type { Transaction } from '../connections/Connection.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { TransactionEventType } from '../enums.js';
+/** Broadcasts transaction lifecycle events (start, commit, rollback) through the EventManager. */
 export declare class TransactionEventBroadcaster {
     private readonly em;
     readonly context?: {
@@ -9,5 +10,6 @@ export declare class TransactionEventBroadcaster {
     constructor(em: EntityManager, context?: {
         topLevelTransaction?: boolean;
     } | undefined);
+    /** Dispatches a transaction lifecycle event to the EventManager. */
     dispatchEvent(event: TransactionEventType, transaction?: Transaction): Promise<void>;
 }

package/events/TransactionEventBroadcaster.js

@@ -1,3 +1,4 @@
+/** Broadcasts transaction lifecycle events (start, commit, rollback) through the EventManager. */
 export class TransactionEventBroadcaster {
     em;
     context;
@@ -5,6 +6,7 @@ export class TransactionEventBroadcaster {
         this.em = em;
         this.context = context;
     }
+    /** Dispatches a transaction lifecycle event to the EventManager. */
     async dispatchEvent(event, transaction) {
         await this.em.getEventManager().dispatchEvent(event, {
             em: this.em,

package/hydration/Hydrator.d.ts

@@ -3,6 +3,7 @@ import type { EntityFactory } from '../entity/EntityFactory.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { Configuration } from '../utils/Configuration.js';
+/** Abstract base class for hydrating entity instances from raw database data. */
 export declare abstract class Hydrator implements IHydrator {
     protected readonly metadata: MetadataStorage;
     protected readonly platform: Platform;
@@ -17,6 +18,7 @@ export declare abstract class Hydrator implements IHydrator {
      * @inheritDoc
      */
     hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    /** Returns whether the hydrator is currently in the middle of hydrating an entity. */
     isRunning(): boolean;
     protected getProperties<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityProperty<T>[];
     protected hydrateProperty<T extends object>(entity: T, prop: EntityProperty<T>, data: EntityData<T>, factory: EntityFactory, newEntity?: boolean, convertCustomTypes?: boolean): void;

package/hydration/Hydrator.js

@@ -1,3 +1,4 @@
+/** Abstract base class for hydrating entity instances from raw database data. */
 /* v8 ignore next */
 export class Hydrator {
     metadata;
@@ -32,6 +33,7 @@ export class Hydrator {
         });
         this.running = false;
     }
+    /** Returns whether the hydrator is currently in the middle of hydrating an entity. */
     isRunning() {
         return this.running;
     }

package/hydration/ObjectHydrator.d.ts

@@ -2,6 +2,7 @@ import type { EntityData, EntityMetadata } from '../typings.js';
 import { Hydrator } from './Hydrator.js';
 import type { EntityFactory } from '../entity/EntityFactory.js';
 type EntityHydrator<T extends object> = (entity: T, data: EntityData<T>, factory: EntityFactory, newEntity: boolean, convertCustomTypes: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean) => void;
+/** @internal JIT-compiled hydrator that converts raw database rows into entity instances with optimized generated code. */
 export declare class ObjectHydrator extends Hydrator {
     #private;
     /**

package/hydration/ObjectHydrator.js

@@ -6,6 +6,7 @@ import { parseJsonSafe, Utils } from '../utils/Utils.js';
 import { ReferenceKind } from '../enums.js';
 import { Raw } from '../utils/RawQueryFragment.js';
 import { ValidationError } from '../errors.js';
+/** @internal JIT-compiled hydrator that converts raw database rows into entity instances with optimized generated code. */
 export class ObjectHydrator extends Hydrator {
     #hydrators = {
         'full~true': new Map(),

package/logging/DefaultLogger.d.ts

@@ -1,4 +1,5 @@
 import type { Logger, LoggerNamespace, LogContext, LoggerOptions } from './Logger.js';
+/** Default logger implementation with colored output, query formatting, and namespace-based filtering. */
 export declare class DefaultLogger implements Logger {
     private readonly options;
     debugMode: boolean | LoggerNamespace[];
@@ -22,6 +23,7 @@ export declare class DefaultLogger implements Logger {
      * @inheritDoc
      */
     setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
+    /** Checks whether logging is enabled for the given namespace, considering context overrides. */
     isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
     /**
      * @inheritDoc
@@ -29,5 +31,6 @@ export declare class DefaultLogger implements Logger {
     logQuery(context: {
         query: string;
     } & LogContext): void;
+    /** Factory method for creating a new DefaultLogger instance. */
     static create(this: void, options: LoggerOptions): DefaultLogger;
 }

package/logging/DefaultLogger.js

@@ -1,4 +1,5 @@
 import { colors } from './colors.js';
+/** Default logger implementation with colored output, query formatting, and namespace-based filtering. */
 export class DefaultLogger {
     options;
     debugMode;
@@ -50,6 +51,7 @@ export class DefaultLogger {
     setDebugMode(debugMode) {
         this.debugMode = debugMode;
     }
+    /** Checks whether logging is enabled for the given namespace, considering context overrides. */
     isEnabled(namespace, context) {
         if (context?.enabled !== undefined) {
             return context.enabled;
@@ -89,6 +91,7 @@ export class DefaultLogger {
         }
         return this.log(namespace, msg, context);
     }
+    /** Factory method for creating a new DefaultLogger instance. */
     static create(options) {
         return new DefaultLogger(options);
     }

package/logging/Logger.d.ts

@@ -1,4 +1,5 @@
 import type { AnyString, Dictionary, Highlighter } from '../typings.js';
+/** Interface for ORM logging, supporting namespaced log levels and query logging. */
 export interface Logger {
     /**
      * Logs a message inside given namespace.
@@ -20,9 +21,12 @@ export interface Logger {
      * Sets active namespaces. Pass `true` to enable all logging.
      */
     setDebugMode(debugMode: boolean | LoggerNamespace[]): void;
+    /** Checks whether logging is enabled for the given namespace. */
     isEnabled(namespace: LoggerNamespace, context?: LogContext): boolean;
 }
+/** Available logging namespaces that can be individually enabled or disabled. */
 export type LoggerNamespace = 'query' | 'query-params' | 'schema' | 'discovery' | 'info' | 'deprecated' | 'slow-query';
+/** Contextual metadata passed alongside log messages, including query details and timing. */
 export interface LogContext extends Dictionary {
     query?: string;
     label?: string;
@@ -39,6 +43,7 @@ export interface LogContext extends Dictionary {
         name?: string;
     };
 }
+/** Options for constructing a Logger instance. */
 export interface LoggerOptions {
     writer: (message: string) => void;
     debugMode?: boolean | LoggerNamespace[];