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

package/entity/WrappedEntity.d.ts

@@ -10,6 +10,7 @@ import { type SerializeOptions } from '../serialization/EntitySerializer.js';
 import type { FindOneOptions, LoadHint } from '../drivers/IDatabaseDriver.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { Configuration } from '../utils/Configuration.js';
+/** @internal Wrapper attached to every managed entity, holding ORM state such as initialization flags, identity map references, and change tracking snapshots. */
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
     __populated?: boolean;
@@ -40,24 +41,43 @@ export declare class WrappedEntity<Entity extends object> {
     private readonly pkSerializer?;
     private readonly pkGetterConverted?;
     constructor(entity: Entity, hydrator: IHydrator, pkGetter?: (e: Entity) => Primary<Entity>, pkSerializer?: (e: Entity) => string, pkGetterConverted?: (e: Entity) => Primary<Entity>);
+    /** Returns whether the entity has been fully loaded from the database. */
     isInitialized(): boolean;
+    /** Returns whether the entity is managed by an EntityManager (tracked in the identity map). */
     isManaged(): boolean;
+    /** Marks the entity as populated or not for serialization purposes. */
     populated(populated?: boolean | undefined): void;
+    /** Sets the serialization context with populate hints, field selections, and exclusions. */
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
+    /** Returns a Reference wrapper for this entity, creating one if it does not already exist. */
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
+    /** Converts the entity to a plain object representation, optionally excluding specified fields. */
     toObject<Ignored extends EntityKey<Entity> = never>(ignoreFields?: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
+    /** Serializes the entity with control over which relations and fields to include or exclude. */
     serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): SerializeDTO<Entity, Hint, Exclude>;
+    /** Converts the entity to a plain object, including all properties regardless of serialization rules. */
     toPOJO(): EntityDTO<Entity>;
+    /** Serializes the entity using its `toJSON` method (supports `JSON.stringify`). */
     toJSON(...args: any[]): EntityDictionary<Entity>;
+    /** Assigns the given data to this entity, updating its properties and relations. */
     assign<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<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
+    /** Loads the specified relations on this entity. */
     populate<Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
+    /** Returns whether this entity has a primary key value set. */
     hasPrimaryKey(): boolean;
+    /** Returns the primary key value, optionally converting custom types to their database representation. */
     getPrimaryKey(convertCustomTypes?: boolean): Primary<Entity> | null;
+    /** Returns all primary key values as an array. Used internally for composite key handling. */
     getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;
+    /** Returns the database schema this entity belongs to. */
     getSchema(): string | undefined;
+    /** Sets the database schema for this entity. */
     setSchema(schema?: string): void;
+    /** Sets the primary key value on the entity. */
     setPrimaryKey(id: Primary<Entity> | null): void;
+    /** Returns the primary key serialized as a string suitable for identity map lookups. */
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
     get __platform(): Platform;

package/entity/WrappedEntity.js

@@ -6,6 +6,7 @@ import { ValidationError } from '../errors.js';
 import { helper } from './wrap.js';
 import { EntitySerializer } from '../serialization/EntitySerializer.js';
 import { expandDotPaths } from './utils.js';
+/** @internal Wrapper attached to every managed entity, holding ORM state such as initialization flags, identity map references, and change tracking snapshots. */
 export class WrappedEntity {
     constructor(entity, hydrator, pkGetter, pkSerializer, pkGetterConverted) {
         this.entity = entity;
@@ -19,15 +20,19 @@ export class WrappedEntity {
         this.__data = {};
         this.__processing = false;
     }
+    /** Returns whether the entity has been fully loaded from the database. */
     isInitialized() {
         return this.__initialized;
     }
+    /** Returns whether the entity is managed by an EntityManager (tracked in the identity map). */
     isManaged() {
         return !!this.__managed;
     }
+    /** Marks the entity as populated or not for serialization purposes. */
     populated(populated = true) {
         this.__populated = populated;
     }
+    /** Sets the serialization context with populate hints, field selections, and exclusions. */
     setSerializationContext(options) {
         const exclude = options.exclude ?? [];
         const context = this.__serializationContext;
@@ -44,29 +49,36 @@ export class WrappedEntity {
             context.fields = new Set(['*']);
         }
     }
+    /** Returns a Reference wrapper for this entity, creating one if it does not already exist. */
     toReference() {
         this.__reference ??= new Reference(this.entity);
         return this.__reference;
     }
+    /** Converts the entity to a plain object representation, optionally excluding specified fields. */
     toObject(ignoreFields) {
         return EntityTransformer.toObject(this.entity, ignoreFields);
     }
+    /** Serializes the entity with control over which relations and fields to include or exclude. */
     serialize(options) {
         return EntitySerializer.serialize(this.entity, options);
     }
+    /** Converts the entity to a plain object, including all properties regardless of serialization rules. */
     toPOJO() {
         return EntityTransformer.toObject(this.entity, [], true);
     }
+    /** Serializes the entity using its `toJSON` method (supports `JSON.stringify`). */
     toJSON(...args) {
         // toJSON methods is added to the prototype during discovery to support automatic serialization via JSON.stringify()
         return this.entity.toJSON(...args);
     }
+    /** Assigns the given data to this entity, updating its properties and relations. */
     assign(data, options) {
         if ('assign' in this.entity) {
             return this.entity.assign(data, options);
         }
         return EntityAssigner.assign(this.entity, data, options);
     }
+    /** Initializes (refreshes) the entity by reloading it from the database. Returns null if not found. */
     async init(options) {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
@@ -77,6 +89,7 @@ export class WrappedEntity {
             schema: this.__schema,
         });
     }
+    /** Loads the specified relations on this entity. */
     async populate(populate, options = {}) {
         if (!this.__em) {
             throw ValidationError.entityNotManaged(this.entity);
@@ -85,10 +98,12 @@ export class WrappedEntity {
         await this.__em.populate(this.entity, populate, options);
         return this.entity;
     }
+    /** Returns whether this entity has a primary key value set. */
     hasPrimaryKey() {
         const pk = this.getPrimaryKey();
         return pk != null;
     }
+    /** Returns the primary key value, optionally converting custom types to their database representation. */
     getPrimaryKey(convertCustomTypes = false) {
         const prop = this.__meta.getPrimaryProps()[0];
         if (!prop) {
@@ -105,7 +120,8 @@ export class WrappedEntity {
         }
         return this.__pk ?? this.pkGetter(this.entity);
     }
-    // this method is currently used only in `Driver.syncCollection` and can be probably removed
+    /** Returns all primary key values as an array. Used internally for composite key handling. */
+    // TODO: currently used only in `Driver.syncCollection` — candidate for removal
     getPrimaryKeys(convertCustomTypes = false) {
         const pk = this.getPrimaryKey(convertCustomTypes);
         if (pk == null) {
@@ -126,16 +142,20 @@ export class WrappedEntity {
         }
         return [pk];
     }
+    /** Returns the database schema this entity belongs to. */
     getSchema() {
         return this.__schema;
     }
+    /** Sets the database schema for this entity. */
     setSchema(schema) {
         this.__schema = schema;
     }
+    /** Sets the primary key value on the entity. */
     setPrimaryKey(id) {
         this.entity[this.__meta.primaryKeys[0]] = id;
         this.__pk = id;
     }
+    /** Returns the primary key serialized as a string suitable for identity map lookups. */
     getSerializedPrimaryKey() {
         return this.pkSerializer(this.entity);
     }

package/entity/defineEntity.d.ts

@@ -10,6 +10,7 @@ import type { IType, Type } from '../types/Type.js';
 import { types } from '../types/index.js';
 import type { Collection } from './Collection.js';
 import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
+/** Union of all option keys supported across all property definition types (scalar, enum, embedded, relations). */
 export type UniversalPropertyKeys = keyof PropertyOptions<any> | keyof EnumOptions<any> | keyof EmbeddedOptions<any, any> | keyof ReferenceOptions<any, any> | keyof ManyToOneOptions<any, any> | keyof OneToManyOptions<any, any> | keyof OneToOneOptions<any, any> | keyof ManyToManyOptions<any, any>;
 type BuilderExtraKeys = '~options' | '~type' | '$type';
 type ExcludeKeys = 'entity' | 'items';
@@ -494,6 +495,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     orphanRemoval(orphanRemoval?: boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     accessor(accessor?: string | boolean): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
 }
+/** Empty options object used as the initial state for property builders. */
 export interface EmptyOptions extends Partial<Record<UniversalPropertyKeys, unknown>> {
 }
 /** @internal */
@@ -510,6 +512,7 @@ type EntityTarget = {
 } | EntityClass;
 declare const propertyBuilders: PropertyBuilders;
 type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'datetime' | 'time' | 'enum';
+/** Map of factory functions for creating type-safe property builders (scalars, enums, embeddables, and relations). */
 export type PropertyBuilders = {
     [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
 } & {
@@ -540,6 +543,7 @@ export type PropertyBuilders = {
 };
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
+/** Metadata descriptor for `defineEntity()`, combining entity options with property definitions. */
 export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
@@ -576,7 +580,9 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         deferMode?: DeferMode | `${DeferMode}`;
     }[];
 }
+/** Defines an entity schema using property builders, with full type inference from the property definitions. */
 export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject>, TBase, TProperties>;
+/** Defines an entity schema for an existing class, combining the class with property builders. */
 export declare function defineEntity<const TEntity = any, const TProperties extends Record<string, any> = Record<string, any>, const TClassName extends string = string, const TTableName extends string = string, const TBase = never, const TClass extends EntityCtor = EntityCtor<TEntity>>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName' | 'hooks'> & {
     class: TClass;
     className?: TClassName;
@@ -588,8 +594,10 @@ export declare function defineEntity<const TEntity = any, const TProperties exte
 export declare namespace defineEntity {
     var properties: PropertyBuilders;
 }
+/** Shorthand alias for `defineEntity.properties` - the property builders for use in `defineEntity()`. */
 export { propertyBuilders as p };
 type EntityHookValue<T, K extends keyof EventSubscriber<T>> = (keyof T | NonNullable<EventSubscriber<T>[K]>)[];
+/** Lifecycle hook definitions for entities created via `defineEntity()`. */
 export interface DefineEntityHooks<T = any> {
     onInit?: EntityHookValue<T, 'onInit'>;
     onLoad?: EntityHookValue<T, 'onLoad'>;
@@ -608,6 +616,7 @@ type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJ
 type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TValue> : never;
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
 type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
+/** Infers the entity type from a `defineEntity()` properties map, resolving builders, base classes, and primary keys. */
 export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
     toObject(...args: any[]): any;
 } ? Pick<IWrappedEntity<{
@@ -632,6 +641,7 @@ type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;
 } ? BasePK : never;
 type CombinePrimaryKeys<ChildPK, BasePK> = [ChildPK] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
+/** Extracts the primary key property names from a properties map by finding builders with `primary: true`. */
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
     [K in keyof Properties]: MaybeReturnType<Properties[K]> extends {
         '~options': {

package/entity/defineEntity.js

@@ -534,4 +534,5 @@ export function defineEntity(meta) {
     return new EntitySchema({ properties, ...options });
 }
 defineEntity.properties = propertyBuilders;
+/** Shorthand alias for `defineEntity.properties` - the property builders for use in `defineEntity()`. */
 export { propertyBuilders as p };

package/enums.d.ts

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