@mikro-orm/core 7.0.0-dev.3 → 7.0.0-dev.300

package/typings.d.ts

@@ -1,5 +1,5 @@
 import type { Transaction } from './connections/Connection.js';
-import { type Cascade, type DeferMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums.js';
+import { type Cascade, type DeferMode, type EmbeddedPrefixMode, type EventType, type LoadStrategy, type PopulatePath, type QueryOrderMap, ReferenceKind } from './enums.js';
 import { type AssignOptions } from './entity/EntityAssigner.js';
 import { type EntityIdentifier } from './entity/EntityIdentifier.js';
 import { type EntityLoaderOptions } from './entity/EntityLoader.js';
@@ -7,27 +7,29 @@ import { type Collection } from './entity/Collection.js';
 import { type EntityFactory } from './entity/EntityFactory.js';
 import { type EntityRepository } from './entity/EntityRepository.js';
 import { Reference, type ScalarReference } from './entity/Reference.js';
-import type { MikroORM } from './MikroORM.js';
 import type { SerializationContext } from './serialization/SerializationContext.js';
 import type { SerializeOptions } from './serialization/EntitySerializer.js';
 import type { MetadataStorage } from './metadata/MetadataStorage.js';
 import type { EntitySchema } from './metadata/EntitySchema.js';
+import type { IndexColumnOptions } from './metadata/types.js';
 import type { Type, types } from './types/index.js';
 import type { Platform } from './platforms/Platform.js';
 import type { Configuration } from './utils/Configuration.js';
-import type { RawQueryFragment } from './utils/RawQueryFragment.js';
+import type { Raw } from './utils/RawQueryFragment.js';
 import type { EntityManager } from './EntityManager.js';
-import type { EmbeddedPrefixMode } from './decorators/Embedded.js';
 import type { EventSubscriber } from './events/EventSubscriber.js';
-import type { FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
+import type { FilterOptions, FindOneOptions, FindOptions, LoadHint } from './drivers/IDatabaseDriver.js';
+export type { Raw };
 export type Constructor<T = unknown> = new (...args: any[]) => T;
 export type Dictionary<T = any> = {
     [k: string]: T;
 };
+export type CompiledFunctions = Record<string, (...args: any[]) => any>;
 export type EntityKey<T = unknown, B extends boolean = false> = string & {
     [K in keyof T]-?: CleanKeys<T, K, B> extends never ? never : K;
 }[keyof T];
 export type EntityValue<T> = T[EntityKey<T>];
+export type EntityDataValue<T> = EntityData<T>[EntityKey<T>];
 export type FilterKey<T> = keyof FilterQuery<T>;
 export type AsyncFunction<R = any, T = Dictionary> = (args: T) => Promise<T>;
 export type Compute<T> = {
@@ -41,7 +43,64 @@ export type IsUnknown<T> = T extends unknown ? unknown extends T ? true : never
 export type IsAny<T> = 0 extends (1 & T) ? true : false;
 export type IsNever<T, True = true, False = false> = [T] extends [never] ? True : False;
 export type MaybePromise<T> = T | Promise<T>;
-export type NoInfer<T> = [T][T extends any ? 0 : never];
+/**
+ * Structural type for matching Collection without triggering full interface evaluation.
+ * Using `T extends CollectionShape` instead of `T extends Collection<any, any>` avoids
+ * forcing TypeScript to evaluate Collection's 30+ methods, preventing instantiation explosion
+ * (~133k → ~2k instantiations).
+ *
+ * Usage:
+ * - Matching only: `T extends CollectionShape`
+ * - With inference: `T extends CollectionShape<infer U>`
+ */
+type CollectionShape<T = any> = {
+    [k: number]: T;
+    readonly owner: object;
+};
+/**
+ * Structural type for matching LoadedCollection (extends CollectionShape with `$` property).
+ *
+ * Usage:
+ * - Matching only: `T extends LoadedCollectionShape`
+ * - With inference: `T extends LoadedCollectionShape<infer U>`
+ */
+type LoadedCollectionShape<T = any> = CollectionShape<T> & {
+    $: any;
+};
+/**
+ * Structural type for matching Reference without triggering full class evaluation.
+ * Using `T extends ReferenceShape` instead of `T extends Reference<any>` avoids
+ * forcing TypeScript to evaluate Reference's methods, preventing instantiation overhead
+ * (~800 → ~15 instantiations).
+ *
+ * Usage:
+ * - Matching only: `T extends ReferenceShape`
+ * - With inference: `T extends ReferenceShape<infer U>`
+ */
+type ReferenceShape<T = any> = {
+    unwrap(): T;
+};
+/**
+ * Structural type for matching LoadedReference (Reference with `$` property).
+ * Note: We don't parameterize ReferenceShape here because for loaded relations,
+ * the Reference unwrap() returns the base type while $ returns the Loaded type.
+ * We infer T from $ to get the full Loaded type for EntityDTO.
+ */
+type LoadedReferenceShape<T = any> = ReferenceShape & {
+    $: T;
+};
+/**
+ * Structural type for matching any loadable relation (Collection, Reference, or array).
+ * Using this instead of `Loadable<any>` in conditional type checks prevents
+ * TypeScript from evaluating the full Collection/Reference interfaces.
+ */
+type LoadableShape = CollectionShape | ReferenceShape | readonly any[];
+export type UnionKeys<T> = T extends any ? keyof T : never;
+export type UnionPropertyType<T, K extends PropertyKey> = T extends any ? (K extends keyof T ? T[K] : never) : never;
+type IsUnion<T, U = T> = T extends any ? ([U] extends [T] ? false : true) : false;
+export type MergeUnion<T> = [T] extends [object] ? (T extends Scalar ? T : IsUnion<T> extends true ? {
+    [K in UnionKeys<T>]: UnionPropertyType<T, K>;
+} : T) : T;
 export type DeepPartial<T> = T & {
     [P in keyof T]?: T[P] extends (infer U)[] ? DeepPartial<U>[] : T[P] extends Readonly<infer U>[] ? Readonly<DeepPartial<U>>[] : DeepPartial<T[P]>;
 };
@@ -51,36 +110,67 @@ export declare const OptionalProps: unique symbol;
 export declare const EagerProps: unique symbol;
 export declare const HiddenProps: unique symbol;
 export declare const Config: unique symbol;
-declare const __optional: unique symbol;
-declare const __hidden: unique symbol;
-declare const __config: unique symbol;
-export type Opt<T = unknown> = T & {
-    [__optional]?: 1;
-};
-export type Hidden<T = unknown> = T & {
-    [__hidden]?: 1;
-};
-export type DefineConfig<T extends TypeConfig> = T & {
-    [__config]?: 1;
-};
+export declare const EntityName: unique symbol;
+export type InferEntityName<T> = T extends {
+    [EntityName]?: infer Name;
+} ? Name extends string ? Name : never : never;
+export type Opt<T = unknown> = T & Opt.Brand;
+export declare namespace Opt {
+    const __optional: unique symbol;
+    interface Brand {
+        [__optional]?: 1;
+    }
+}
+export type RequiredNullable<T = never> = (T & RequiredNullable.Brand) | null;
+export declare namespace RequiredNullable {
+    const __requiredNullable: unique symbol;
+    interface Brand {
+        [__requiredNullable]?: 1;
+    }
+}
+export type Hidden<T = unknown> = T & Hidden.Brand;
+export declare namespace Hidden {
+    const __hidden: unique symbol;
+    interface Brand {
+        [__hidden]?: 1;
+    }
+}
+export type DefineConfig<T extends TypeConfig> = T & DefineConfig.Brand;
+export declare namespace DefineConfig {
+    const __config: unique symbol;
+    interface Brand {
+        [__config]?: 1;
+    }
+}
 export type CleanTypeConfig<T> = Compute<Pick<T, Extract<keyof T, keyof TypeConfig>>>;
 export interface TypeConfig {
     forceObject?: boolean;
 }
-export type UnwrapPrimary<T> = T extends Scalar ? T : T extends Reference<infer U> ? Primary<U> : Primary<T>;
+declare const __selectedType: unique symbol;
+declare const __loadedType: unique symbol;
+declare const __loadHint: unique symbol;
+/**
+ * Expands a populate hint into all its prefixes.
+ * e.g., Prefixes<'a.b.c'> = 'a' | 'a.b' | 'a.b.c'
+ * This reflects that loading 'a.b.c' means 'a' and 'a.b' are also loaded.
+ * Special case: '*' returns string to ensure Loaded<T, '*'> is assignable to any Loaded<T, Hint>.
+ */
+export type Prefixes<S extends string> = S extends '*' ? string : S extends `${infer H}.${infer T}` ? H | `${H}.${Prefixes<T>}` : S;
+export type UnwrapPrimary<T> = T extends Scalar ? T : T extends ReferenceShape<infer U> ? Primary<U> : Primary<T>;
 type PrimaryPropToType<T, Keys extends (keyof T)[]> = {
     [Index in keyof Keys]: UnwrapPrimary<T[Keys[Index]]>;
 };
 type ReadonlyPrimary<T> = T extends any[] ? Readonly<T> : T;
 export type Primary<T> = IsAny<T> extends true ? any : T extends {
     [PrimaryKeyProp]?: infer PK;
-} ? (PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : (PK extends (keyof T)[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK)) : T extends {
+} ? PK extends undefined ? Omit<T, typeof PrimaryKeyProp> : PK extends keyof T ? ReadonlyPrimary<UnwrapPrimary<T[PK]>> : PK extends (keyof T)[] ? ReadonlyPrimary<PrimaryPropToType<T, PK>> : PK : T extends {
     _id?: infer PK;
 } ? ReadonlyPrimary<PK> | string : T extends {
-    uuid?: infer PK;
-} ? ReadonlyPrimary<PK> : T extends {
     id?: infer PK;
+} ? ReadonlyPrimary<PK> : T extends {
+    uuid?: infer PK;
 } ? ReadonlyPrimary<PK> : T;
+/** @internal */
 export type PrimaryProperty<T> = T extends {
     [PrimaryKeyProp]?: infer PK;
 } ? (PK extends keyof T ? PK : (PK extends any[] ? PK[number] : never)) : T extends {
@@ -88,10 +178,10 @@ export type PrimaryProperty<T> = T extends {
 } ? (T extends {
     id?: any;
 } ? 'id' | '_id' : '_id') : T extends {
-    uuid?: any;
-} ? 'uuid' : T extends {
     id?: any;
-} ? 'id' : never;
+} ? 'id' : T extends {
+    uuid?: any;
+} ? 'uuid' : never;
 export type IPrimaryKeyValue = number | string | bigint | Date | {
     toHexString(): string;
 };
@@ -99,22 +189,35 @@ export type IPrimaryKey<T extends IPrimaryKeyValue = IPrimaryKeyValue> = T;
 export type Scalar = boolean | number | string | bigint | symbol | Date | RegExp | Uint8Array | {
     toHexString(): string;
 };
+type Primitive = boolean | number | string | bigint | symbol;
 export type ExpandScalar<T> = null | (T extends string ? T | RegExp : T extends Date ? Date | string : T extends bigint ? bigint | string | number : T);
+/** Marker interface for query builders that can be used as subqueries */
+export interface Subquery {
+    readonly __subquery: true;
+}
 export type OperatorMap<T> = {
     $and?: ExpandQuery<T>[];
     $or?: ExpandQuery<T>[];
-    $eq?: ExpandScalar<T> | readonly ExpandScalar<T>[];
-    $ne?: ExpandScalar<T>;
-    $in?: readonly ExpandScalar<T>[];
-    $nin?: readonly ExpandScalar<T>[];
+    $eq?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $ne?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $in?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
+    $nin?: readonly ExpandScalar<T>[] | readonly Primary<T>[] | Raw | Subquery;
     $not?: ExpandQuery<T>;
     $none?: ExpandQuery<T>;
     $some?: ExpandQuery<T>;
     $every?: ExpandQuery<T>;
-    $gt?: ExpandScalar<T>;
-    $gte?: ExpandScalar<T>;
-    $lt?: ExpandScalar<T>;
-    $lte?: ExpandScalar<T>;
+    $size?: number | {
+        $eq?: number;
+        $ne?: number;
+        $gt?: number;
+        $gte?: number;
+        $lt?: number;
+        $lte?: number;
+    };
+    $gt?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $gte?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $lt?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
+    $lte?: ExpandScalar<T> | readonly ExpandScalar<T>[] | Subquery;
     $like?: string;
     $re?: string;
     $ilike?: string;
@@ -127,25 +230,24 @@ export type OperatorMap<T> = {
     $hasKeys?: readonly string[];
     $hasSomeKeys?: readonly string[];
 };
-export type FilterItemValue<T> = T | ExpandScalar<T> | Primary<T>;
+export type FilterItemValue<T> = T | ExpandScalar<T> | Primary<T> | Raw;
 export type FilterValue<T> = OperatorMap<FilterItemValue<T>> | FilterItemValue<T> | FilterItemValue<T>[] | null;
+type FilterObjectProp<T, K extends PropertyKey> = K extends keyof MergeUnion<T> ? MergeUnion<T>[K] : K extends keyof T ? T[K] : never;
+type ExpandQueryMerged<T> = [T] extends [object] ? [T] extends [Scalar] ? never : FilterQuery<MergeUnion<T>> : FilterValue<T>;
 export type FilterObject<T> = {
-    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<T[K]>> | FilterValue<ExpandProperty<T[K]>> | null;
+    -readonly [K in EntityKey<T>]?: ExpandQuery<ExpandProperty<FilterObjectProp<T, K>>> | ExpandQueryMerged<ExpandProperty<FilterObjectProp<T, K>>> | FilterValue<ExpandProperty<FilterObjectProp<T, K>>> | null;
 };
-export type ExpandObject<T> = T extends object ? T extends Scalar ? never : FilterObject<T> : never;
 export type ExpandQuery<T> = T extends object ? T extends Scalar ? never : FilterQuery<T> : FilterValue<T>;
 export type EntityProps<T> = {
     -readonly [K in EntityKey<T>]?: T[K];
 };
 export type ObjectQuery<T> = OperatorMap<T> & FilterObject<T>;
 export type FilterQuery<T> = ObjectQuery<T> | NonNullable<ExpandScalar<Primary<T>>> | NonNullable<EntityProps<T> & OperatorMap<T>> | FilterQuery<T>[];
-export type QBFilterQuery<T = any> = ObjectQuery<T> | Dictionary;
 export interface IWrappedEntity<Entity extends object> {
     isInitialized(): boolean;
-    isTouched(): boolean;
     isManaged(): boolean;
     populated(populated?: boolean): void;
-    populate<Hint extends string = never>(populate: AutoPath<Entity, Hint>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Hint extends string = never, Fields extends string = never>(populate: readonly AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     init<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Exclude>): Promise<Loaded<Entity, Hint, Fields, Exclude> | null>;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject(): EntityDTO<Entity>;
@@ -153,7 +255,7 @@ export interface IWrappedEntity<Entity extends object> {
     toObject<Ignored extends EntityKey<Entity>>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toJSON(...args: any[]): EntityDTO<Entity>;
     toPOJO(): EntityDTO<Entity>;
-    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
+    serialize<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     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, Convert>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     getSchema(): string | undefined;
@@ -173,10 +275,9 @@ export interface IWrappedEntityInternal<Entity extends object> extends IWrappedE
     __factory: EntityFactory;
     __hydrator: IHydrator;
     __initialized: boolean;
-    __touched: boolean;
     __originalEntityData?: EntityData<Entity>;
     __loadedProperties: Set<string>;
-    __identifier?: EntityIdentifier;
+    __identifier?: EntityIdentifier | EntityIdentifier[];
     __managed: boolean;
     __processing: boolean;
     __schema?: string;
@@ -193,20 +294,21 @@ export interface IWrappedEntityInternal<Entity extends object> extends IWrappedE
     };
 }
 export type AnyEntity<T = any> = Partial<T>;
-export type EntityClass<T> = Function & {
+export type EntityClass<T = any> = Function & {
     prototype: T;
 };
-export type EntityClassGroup<T> = {
-    entity: EntityClass<T>;
-    schema: EntityMetadata<T> | EntitySchema<T>;
-};
-export type EntityName<T> = string | EntityClass<T> | EntitySchema<T, any> | {
-    name: string;
-};
+export type EntityName<T = any> = EntityClass<T> | EntityCtor<T> | EntitySchema<T, any>;
 export type GetRepository<Entity extends {
     [k: PropertyKey]: any;
-}, Fallback> = Entity[typeof EntityRepositoryType] extends EntityRepository<Entity> | undefined ? NonNullable<Entity[typeof EntityRepositoryType]> : Fallback;
-export type EntityDataPropValue<T> = T | Primary<T>;
+}, Fallback> = Entity[typeof EntityRepositoryType] extends EntityRepository<any> | undefined ? NonNullable<Entity[typeof EntityRepositoryType]> : Fallback;
+type PolymorphicPrimaryInner<T> = T extends object ? Primary<T> extends readonly [infer First, infer Second, ...infer Rest] ? readonly [string, First, Second, ...Rest] | [string, First, Second, ...Rest] : readonly [string, Primary<T>] | [string, Primary<T>] : never;
+/**
+ * Tuple format for polymorphic FK values: [discriminator, ...pkValues]
+ * Distributes over unions, so `Post | Comment` becomes `['post', number] | ['comment', number]`
+ * For composite keys like [tenantId, orgId], becomes ['discriminator', tenantId, orgId]
+ */
+export type PolymorphicPrimary<T> = true extends IsUnion<T> ? PolymorphicPrimaryInner<T> : never;
+export type EntityDataPropValue<T> = T | Primary<T> | PolymorphicPrimary<T>;
 type ExpandEntityProp<T, C extends boolean = false> = T extends Record<string, any> ? {
     [K in keyof T as CleanKeys<T, K>]?: EntityDataProp<ExpandProperty<T[K]>, C> | EntityDataPropValue<ExpandProperty<T[K]>> | null;
 } | EntityDataPropValue<ExpandProperty<T>> : T;
@@ -216,16 +318,20 @@ type ExpandRequiredEntityPropObject<T, I = never, C extends boolean = false> = {
 } & {
     [K in keyof T as OptionalKeys<T, K, I>]?: RequiredEntityDataProp<ExpandProperty<T[K]>, T, C> | EntityDataPropValue<ExpandProperty<T[K]>> | null | undefined;
 };
-export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends {
+type NonArrayObject = object & {
+    [Symbol.iterator]?: never;
+};
+export type EntityDataProp<T, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? (C extends true ? Raw : Runtime) : T extends Reference<infer U> ? EntityDataNested<U, C> : T extends ScalarReference<infer U> ? EntityDataProp<U, C> : T extends Collection<infer U, any> ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : T extends readonly (infer U)[] ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
-export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : T extends Scalar ? T : T extends {
+} ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? EntityDataNested<U, C> : T extends CollectionShape<infer U> ? U | U[] | EntityDataNested<U & object, C> | EntityDataNested<U & object, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | EntityDataNested<U, C> | EntityDataNested<U, C>[] : U[] | EntityDataNested<U, C>[] : EntityDataNested<T, C>;
+export type RequiredEntityDataProp<T, O, C extends boolean> = T extends Date ? string | Date : Exclude<T, null> extends RequiredNullable.Brand ? T | null : T extends Scalar ? T : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends {
     __runtime?: infer Runtime;
     __raw?: infer Raw;
-} ? (C extends true ? Raw : Runtime) : T extends Reference<infer U> ? RequiredEntityDataNested<U, O, C> : T extends ScalarReference<infer U> ? RequiredEntityDataProp<U, O, C> : T extends Collection<infer U, any> ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : T extends readonly (infer U)[] ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
+} ? (C extends true ? Raw : Runtime) : T extends ReferenceShape<infer U> ? RequiredEntityDataNested<U, O, C> : T extends CollectionShape<infer U> ? U | U[] | RequiredEntityDataNested<U & object, O, C> | RequiredEntityDataNested<U & object, O, C>[] : T extends readonly (infer U)[] ? U extends NonArrayObject ? U | U[] | RequiredEntityDataNested<U, O, C> | RequiredEntityDataNested<U, O, C>[] : U[] | RequiredEntityDataNested<U, O, C>[] : RequiredEntityDataNested<T, O, C>;
 export type EntityDataNested<T, C extends boolean = false> = T extends undefined ? never : T extends any[] ? Readonly<T> : EntityData<T, C> | ExpandEntityProp<T, C>;
-type EntityDataItem<T, C extends boolean> = C extends false ? T | EntityDataProp<T, C> | null : EntityDataProp<T, C> | null;
+type UnwrapScalarRef<T> = T extends ScalarReference<infer U> ? U : T;
+type EntityDataItem<T, C extends boolean> = C extends false ? UnwrapScalarRef<T> | EntityDataProp<T, C> | Raw | null : EntityDataProp<T, C> | Raw | null;
 export type RequiredEntityDataNested<T, O, C extends boolean> = T extends any[] ? Readonly<T> : RequiredEntityData<T, O> | ExpandRequiredEntityProp<T, O, C>;
 type ExplicitlyOptionalProps<T> = (T extends {
     [OptionalProps]?: infer K;
@@ -233,19 +339,22 @@ type ExplicitlyOptionalProps<T> = (T extends {
     [K in keyof T]: T[K] extends Opt ? K : never;
 }[keyof T] & {});
 type NullableKeys<T, V = null> = {
-    [K in keyof T]: V extends T[K] ? K : never;
+    [K in keyof T]: unknown extends T[K] ? never : V extends T[K] ? K : never;
+}[keyof T];
+type RequiredNullableKeys<T> = {
+    [K in keyof T]: Exclude<T[K], null> extends RequiredNullable.Brand ? K : never;
 }[keyof T];
-type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | NonNullable<NullableKeys<T, null | undefined>>;
-type IsOptional<T, K extends keyof T, I> = T[K] extends Collection<any, any> ? true : ExtractType<T[K]> extends I ? true : K extends ProbablyOptionalProps<T> ? true : false;
+type ProbablyOptionalProps<T> = PrimaryProperty<T> | ExplicitlyOptionalProps<T> | Exclude<NonNullable<NullableKeys<T, null | undefined>>, RequiredNullableKeys<T>>;
+type IsOptional<T, K extends keyof T, I> = T[K] extends CollectionShape ? true : ExtractType<T[K]> extends I ? true : K extends ProbablyOptionalProps<T> ? true : false;
 type RequiredKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? CleanKeys<T, K> : never;
 type OptionalKeys<T, K extends keyof T, I> = IsOptional<T, K, I> extends false ? never : CleanKeys<T, K>;
 export type EntityData<T, C extends boolean = false> = {
-    [K in EntityKey<T>]?: EntityDataItem<T[K], C>;
+    [K in EntityKey<T>]?: EntityDataItem<T[K] & {}, C>;
 };
 export type RequiredEntityData<T, I = never, C extends boolean = false> = {
-    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]>;
+    [K in keyof T as RequiredKeys<T, K, I>]: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw;
 } & {
-    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | null;
+    [K in keyof T as OptionalKeys<T, K, I>]?: T[K] | RequiredEntityDataProp<T[K], T, C> | Primary<T[K]> | PolymorphicPrimary<T[K]> | Raw | null;
 };
 export type EntityDictionary<T> = EntityData<T> & Record<any, any>;
 type ExtractEagerProps<T> = T extends {
@@ -270,7 +379,7 @@ export type Ref<T> = T extends any ? IsAny<T> extends true ? Reference<T & objec
 type ExtractHiddenProps<T> = (T extends {
     [HiddenProps]?: infer K;
 } ? K : never) | ({
-    [K in keyof T]: T[K] extends Hidden ? K : never;
+    [K in keyof T]: T[K] extends Primitive ? (T[K] extends Hidden ? K : never) : never;
 }[keyof T] & {});
 type ExcludeHidden<T, K extends keyof T> = K extends ExtractHiddenProps<T> ? never : K;
 type ExtractConfig<T> = T extends {
@@ -280,11 +389,15 @@ type PreferExplicitConfig<E, I> = IsNever<E, I, E>;
 type PrimaryOrObject<T, U, C extends TypeConfig> = PreferExplicitConfig<C, ExtractConfig<T>>['forceObject'] extends true ? {
     [K in PrimaryProperty<U> & keyof U]: U[K];
 } : Primary<U>;
-export type EntityDTOProp<E, T, C extends TypeConfig = never> = T extends Scalar ? T : T extends {
+type DTOWrapper<T, C extends TypeConfig, Flat extends boolean> = Flat extends true ? EntityDTOFlat<T, C> : EntityDTO<T, C>;
+export type EntityDTOProp<E, T, C extends TypeConfig = never, Flat extends boolean = false> = T extends Scalar ? T : T extends ScalarReference<infer U> ? U : T extends {
     __serialized?: infer U;
-} ? U : T extends LoadedReference<infer U> ? EntityDTO<U, C> : T extends Reference<infer U> ? PrimaryOrObject<E, U, C> : T extends ScalarReference<infer U> ? U : T extends LoadedCollection<infer U> ? EntityDTO<U, C>[] : T extends Collection<infer U> ? PrimaryOrObject<E, U, C>[] : T extends readonly (infer U)[] ? (T extends readonly any[] ? T : U[]) : T extends Relation<T> ? EntityDTO<T, C> : T;
-type DTOProbablyOptionalProps<T> = NonNullable<NullableKeys<T, undefined>>;
-type DTOIsOptional<T, K extends keyof T> = T[K] extends LoadedCollection<any> ? false : K extends PrimaryProperty<T> ? false : K extends DTOProbablyOptionalProps<T> ? true : false;
+} ? (IsUnknown<U> extends false ? U : T) : T extends LoadedReferenceShape<infer U> ? DTOWrapper<U, C, Flat> : T extends ReferenceShape<infer U> ? PrimaryOrObject<E, U, C> : T extends LoadedCollectionShape<infer U> ? DTOWrapper<U & object, C, Flat>[] : T extends CollectionShape<infer U> ? PrimaryOrObject<E, U & object, C>[] : T extends readonly (infer U)[] ? U extends Scalar ? T : EntityDTOProp<E, U, C, Flat>[] : T extends Relation<T> ? DTOWrapper<T, C, Flat> : T;
+type UnwrapLoadedEntity<T> = T extends {
+    [__loadedType]?: infer U;
+} ? NonNullable<U> : T;
+type DTOProbablyOptionalProps<T> = NonNullable<NullableKeys<UnwrapLoadedEntity<T>, undefined>>;
+type DTOIsOptional<T, K extends keyof T> = T[K] extends LoadedCollectionShape ? false : K extends PrimaryProperty<UnwrapLoadedEntity<T>> ? false : K extends DTOProbablyOptionalProps<T> ? true : false;
 type DTORequiredKeys<T, K extends keyof T> = DTOIsOptional<T, K> extends false ? ExcludeHidden<T, K> & CleanKeys<T, K> : never;
 type DTOOptionalKeys<T, K extends keyof T> = DTOIsOptional<T, K> extends false ? never : ExcludeHidden<T, K> & CleanKeys<T, K>;
 export type EntityDTO<T, C extends TypeConfig = never> = {
@@ -292,22 +405,84 @@ export type EntityDTO<T, C extends TypeConfig = never> = {
 } & {
     [K in keyof T as DTOOptionalKeys<T, K>]?: EntityDTOProp<T, T[K], C> | AddOptional<T[K]>;
 };
-export type CheckCallback<T> = (columns: Record<keyof T, string>) => string;
-export type GeneratedColumnCallback<T> = (columns: Record<keyof T, string>) => string;
+/**
+ * @internal
+ * 1-pass variant of EntityDTO — ~2x cheaper to resolve but all keys are required
+ * (optional keys use `| undefined` in value type instead of `?` modifier).
+ * Use only for internal type computations (output types), never as a user-facing
+ * function parameter type where generic assignability checks are needed.
+ */
+export type EntityDTOFlat<T, C extends TypeConfig = never> = {
+    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K>]: EntityDTOProp<T, T[K], C, true> | AddOptional<T[K]>;
+};
+/**
+ * @internal
+ * Single-pass fused type that combines Loaded + EntityDTO into one mapped type.
+ * ~40x faster than `EntityDTO<Loaded<T, H>>` for populated entities.
+ */
+type SerializeTopHints<H extends string> = H extends `${infer Top}.${string}` ? Top : H;
+type SerializeSubHints<K extends string, H extends string> = H extends `${K}.${infer Rest}` ? Rest : never;
+type SerializePropValue<T, K extends keyof T, H extends string, C extends TypeConfig = never> = (K & string) extends SerializeTopHints<H> ? NonNullable<T[K]> extends CollectionShape<infer U> ? SerializeDTO<U & object, SerializeSubHints<K & string, H>, never, C>[] : SerializeDTO<ExpandProperty<T[K]>, SerializeSubHints<K & string, H>, never, C> | Extract<T[K], null | undefined> : EntityDTOProp<T, T[K], C>;
+export type SerializeDTO<T, H extends string = never, E extends string = never, C extends TypeConfig = never> = string extends H ? EntityDTOFlat<T, C> : {
+    [K in keyof T as ExcludeHidden<T, K> & CleanKeys<T, K> & (IsNever<E> extends true ? K : Exclude<K, E>)]: SerializePropValue<T, K, H, C> | Extract<T[K], null | undefined>;
+};
+type TargetKeys<T> = T extends EntityClass<infer P> ? keyof P : keyof T;
+type PropertyName<T> = IsUnknown<T> extends false ? TargetKeys<T> : string;
+export type FormulaTable = {
+    alias: string;
+    name: string;
+    schema?: string;
+    qualifiedName: string;
+    toString: () => string;
+};
+/**
+ * Table reference for schema callbacks (indexes, checks, generated columns).
+ * Unlike FormulaTable, this has no alias since schema generation doesn't use query aliases.
+ */
+export type SchemaTable = {
+    name: string;
+    schema?: string;
+    qualifiedName: string;
+    toString: () => string;
+};
+/**
+ * Column mapping for formula callbacks. Maps property names to fully-qualified alias.fieldName.
+ * Has toString() returning the main alias for backwards compatibility with old formula syntax.
+ * @example
+ * // New recommended syntax - use cols.propName for fully-qualified references
+ * formula: cols => `${cols.firstName} || ' ' || ${cols.lastName}`
+ *
+ * // Old syntax still works - cols.toString() returns the alias
+ * formula: cols => `${cols}.first_name || ' ' || ${cols}.last_name`
+ */
+export type FormulaColumns<T> = Record<PropertyName<T>, string> & {
+    toString(): string;
+};
+/**
+ * Column mapping for schema callbacks (indexes, checks, generated columns).
+ * Maps property names to field names. For TPT entities, only includes properties
+ * that belong to the current table (not inherited properties from parent tables).
+ */
+export type SchemaColumns<T> = Record<PropertyName<T>, string>;
+export type IndexCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable, indexName: string) => string | Raw;
+export type FormulaCallback<T> = (columns: FormulaColumns<T>, table: FormulaTable) => string | Raw;
+export type CheckCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
+export type GeneratedColumnCallback<T> = (columns: Record<PropertyName<T>, string>, table: SchemaTable) => string | Raw;
 export interface CheckConstraint<T = any> {
     name?: string;
     property?: string;
-    expression: string | CheckCallback<T>;
+    expression: string | Raw | CheckCallback<T>;
 }
 export type AnyString = string & {};
 export interface EntityProperty<Owner = any, Target = any> {
     name: EntityKey<Owner>;
     entity: () => EntityName<Owner>;
+    target: EntityClass<Target>;
     type: keyof typeof types | AnyString;
     runtimeType: 'number' | 'string' | 'boolean' | 'bigint' | 'Buffer' | 'Date' | 'object' | 'any' | AnyString;
     targetMeta?: EntityMetadata<Target>;
     columnTypes: string[];
-    generated?: string | GeneratedColumnCallback<Owner>;
+    generated?: string | Raw | GeneratedColumnCallback<Owner>;
     customType?: Type<any>;
     customTypes: (Type<any> | undefined)[];
     hasConvertToJSValueSQL: boolean;
@@ -328,7 +503,8 @@ export interface EntityProperty<Owner = any, Target = any> {
     fieldNameRaw?: string;
     default?: string | number | boolean | null;
     defaultRaw?: string;
-    formula?: (alias: string) => string;
+    formula?: FormulaCallback<Owner>;
+    filters?: FilterOptions;
     prefix?: string | boolean;
     prefixMode?: EmbeddedPrefixMode;
     embedded?: [EntityKey<Owner>, EntityKey<Owner>];
@@ -336,16 +512,23 @@ export interface EntityProperty<Owner = any, Target = any> {
     embeddable: EntityClass<Owner>;
     embeddedProps: Dictionary<EntityProperty>;
     discriminatorColumn?: string;
+    discriminator?: string;
+    polymorphic?: boolean;
+    polymorphTargets?: EntityMetadata[];
+    discriminatorMap?: Dictionary<EntityClass<Target>>;
+    discriminatorValue?: string;
     object?: boolean;
     index?: boolean | string;
     unique?: boolean | string;
     nullable?: boolean;
     inherited?: boolean;
+    renamedFrom?: string;
+    stiFieldNames?: string[];
+    stiFieldNameMap?: Dictionary<string>;
     unsigned?: boolean;
     mapToPk?: boolean;
     persist?: boolean;
     hydrate?: boolean;
-    trackChanges?: boolean;
     hidden?: boolean;
     enum?: boolean;
     items?: (number | string)[];
@@ -356,6 +539,7 @@ export interface EntityProperty<Owner = any, Target = any> {
     setter?: boolean;
     getter?: boolean;
     getterName?: keyof Owner;
+    accessor?: EntityKey<Owner>;
     cascade: Cascade[];
     orphanRemoval?: boolean;
     onCreate?: (entity: Owner, em: EntityManager) => any;
@@ -372,13 +556,14 @@ export interface EntityProperty<Owner = any, Target = any> {
     fixedOrder?: boolean;
     fixedOrderColumn?: string;
     pivotTable: string;
-    pivotEntity: string;
+    pivotEntity: EntityClass<Target>;
     joinColumns: string[];
     ownColumns: string[];
     inverseJoinColumns: string[];
     referencedColumnNames: string[];
     referencedTableName: string;
     referencedPKs: EntityKey<Owner>[];
+    targetKey?: string;
     serializer?: (value: any, options?: SerializeOptions<any>) => any;
     serializedName?: string;
     comment?: string;
@@ -388,18 +573,33 @@ export interface EntityProperty<Owner = any, Target = any> {
     optional?: boolean;
     ignoreSchemaChanges?: ('type' | 'extra' | 'default')[];
     deferMode?: DeferMode;
+    createForeignKeyConstraint: boolean;
+    foreignKeyName?: string;
 }
-export declare class EntityMetadata<T = any> {
+export declare class EntityMetadata<Entity = any, Class extends EntityCtor<Entity> = EntityCtor<Entity>> {
     private static counter;
     readonly _id: number;
     readonly propertyOrder: Map<string, number>;
     constructor(meta?: Partial<EntityMetadata>);
-    addProperty(prop: Partial<EntityProperty<T>>, sync?: boolean): void;
+    addProperty(prop: Partial<EntityProperty<Entity>>): void;
     removeProperty(name: string, sync?: boolean): void;
-    getPrimaryProps(): EntityProperty<T>[];
-    getPrimaryProp(): EntityProperty<T>;
+    getPrimaryProps(flatten?: boolean): EntityProperty<Entity>[];
+    getPrimaryProp(): EntityProperty<Entity>;
+    /**
+     * Creates a mapping from property names to field names.
+     * @param alias - Optional alias to prefix field names. Can be a string (same for all) or a function (per-property).
+     *                When provided, also adds toString() returning the alias for backwards compatibility with formulas.
+     * @param toStringAlias - Optional alias to return from toString(). Defaults to `alias` when it's a string.
+     */
+    createColumnMappingObject(alias?: string | ((prop: EntityProperty<Entity>) => string), toStringAlias?: string): FormulaColumns<Entity>;
+    /**
+     * Creates a column mapping for schema callbacks (indexes, checks, generated columns).
+     * For TPT entities, only includes properties that belong to the current table (ownProps).
+     */
+    createSchemaColumnMappingObject(): SchemaColumns<Entity>;
     get tableName(): string;
     set tableName(name: string);
+    get uniqueName(): string;
     sync(initIndexes?: boolean, config?: Configuration): void;
     private initIndexes;
     /** @internal */
@@ -409,67 +609,87 @@ export interface SimpleColumnMeta {
     name: string;
     type: string;
 }
-export interface EntityMetadata<T = any> {
+export type EntityCtor<T = any> = abstract new (...args: any[]) => T;
+export interface EntityMetadata<Entity = any, Class extends EntityCtor<Entity> = EntityCtor<Entity>> {
     name?: string;
     className: string;
     tableName: string;
     schema?: string;
     pivotTable?: boolean;
     virtual?: boolean;
-    expression?: string | ((em: any, where: FilterQuery<T>, options: FindOptions<T, any, any, any>) => MaybePromise<RawQueryFragment | object | string>);
-    discriminatorColumn?: EntityKey<T> | AnyString;
+    /** True if this entity represents a database view (not a virtual entity). Accepts `{ materialized: true }` as input, normalized to `true` during sync. */
+    view?: boolean | {
+        materialized?: boolean;
+        withData?: boolean;
+    };
+    /** True if this is a materialized view (PostgreSQL only). Requires `view: true`. */
+    materialized?: boolean;
+    /** For materialized views, whether data is populated on creation. Defaults to true. */
+    withData?: boolean;
+    expression?: string | ((em: any, where: ObjectQuery<Entity>, options: FindOptions<Entity, any, any, any>, stream?: boolean) => MaybePromise<Raw | object | string>);
+    discriminatorColumn?: EntityKey<Entity> | AnyString;
     discriminatorValue?: number | string;
-    discriminatorMap?: Dictionary<string>;
+    discriminatorMap?: Dictionary<EntityClass>;
     embeddable: boolean;
-    constructorParams: EntityKey<T>[];
+    constructorParams?: (keyof Entity)[];
     forceConstructor: boolean;
-    toJsonParams: string[];
-    extends: string;
+    extends?: EntityName<Entity>;
     collection: string;
     path: string;
-    primaryKeys: EntityKey<T>[];
+    primaryKeys: EntityKey<Entity>[];
     simplePK: boolean;
     compositePK: boolean;
-    versionProperty: EntityKey<T>;
-    concurrencyCheckKeys: Set<EntityKey<T>>;
-    serializedPrimaryKey: EntityKey<T>;
+    versionProperty: EntityKey<Entity>;
+    concurrencyCheckKeys: Set<EntityKey<Entity>>;
+    serializedPrimaryKey?: EntityKey<Entity>;
     properties: {
-        [K in EntityKey<T>]: EntityProperty<T>;
+        [K in EntityKey<Entity>]: EntityProperty<Entity>;
     };
-    props: EntityProperty<T>[];
-    relations: EntityProperty<T>[];
-    bidirectionalRelations: EntityProperty<T>[];
+    props: EntityProperty<Entity>[];
+    relations: EntityProperty<Entity>[];
+    bidirectionalRelations: EntityProperty<Entity>[];
     referencingProperties: {
-        meta: EntityMetadata<T>;
-        prop: EntityProperty<T>;
+        meta: EntityMetadata<Entity>;
+        prop: EntityProperty<Entity>;
     }[];
-    comparableProps: EntityProperty<T>[];
-    trackingProps: EntityProperty<T>[];
-    hydrateProps: EntityProperty<T>[];
-    uniqueProps: EntityProperty<T>[];
-    getterProps: EntityProperty<T>[];
+    comparableProps: EntityProperty<Entity>[];
+    trackingProps: EntityProperty<Entity>[];
+    hydrateProps: EntityProperty<Entity>[];
+    validateProps: EntityProperty<Entity>[];
+    uniqueProps: EntityProperty<Entity>[];
+    getterProps: EntityProperty<Entity>[];
     indexes: {
-        properties: EntityKey<T> | EntityKey<T>[];
+        properties?: EntityKey<Entity> | EntityKey<Entity>[];
         name?: string;
         type?: string;
         options?: Dictionary;
-        expression?: string;
+        expression?: string | IndexCallback<Entity>;
+        columns?: IndexColumnOptions[];
+        include?: EntityKey<Entity> | EntityKey<Entity>[];
+        fillFactor?: number;
+        invisible?: boolean;
+        disabled?: boolean;
+        clustered?: boolean;
     }[];
     uniques: {
-        properties: EntityKey<T> | EntityKey<T>[];
+        properties?: EntityKey<Entity> | EntityKey<Entity>[];
         name?: string;
         options?: Dictionary;
-        expression?: string;
-        deferMode?: DeferMode;
+        expression?: string | IndexCallback<Entity>;
+        deferMode?: DeferMode | `${DeferMode}`;
+        columns?: IndexColumnOptions[];
+        include?: EntityKey<Entity> | EntityKey<Entity>[];
+        fillFactor?: number;
+        disabled?: boolean;
     }[];
-    checks: CheckConstraint<T>[];
+    checks: CheckConstraint<Entity>[];
     repositoryClass?: string;
     repository: () => EntityClass<EntityRepository<any>>;
     hooks: {
-        [K in EventType]?: (keyof T | EventSubscriber<T>[EventType])[];
+        [K in EventType]?: (keyof Entity | EventSubscriber<Entity>[EventType])[];
     };
-    prototype: T;
-    class: EntityClass<T>;
+    prototype: Entity;
+    class: Class;
     abstract: boolean;
     filters: Dictionary<FilterDef>;
     comment?: string;
@@ -477,8 +697,32 @@ export interface EntityMetadata<T = any> {
     hasUniqueProps?: boolean;
     readonly?: boolean;
     polymorphs?: EntityMetadata[];
-    root: EntityMetadata<T>;
+    root: EntityMetadata<Entity>;
     definedProperties: Dictionary;
+    /** For polymorphic M:N pivot tables, maps discriminator values to entity classes */
+    polymorphicDiscriminatorMap?: Dictionary<EntityClass>;
+    /** Inheritance type: 'sti' (Single Table Inheritance) or 'tpt' (Table-Per-Type). Only set on root entities. */
+    inheritanceType?: 'sti' | 'tpt';
+    /** For TPT: direct parent entity metadata (the entity this one extends). */
+    tptParent?: EntityMetadata;
+    /** For TPT: direct child entities (entities that extend this one). */
+    tptChildren?: EntityMetadata[];
+    /** For TPT: all non-abstract descendants, sorted by depth (deepest first). Precomputed during discovery. */
+    allTPTDescendants?: EntityMetadata[];
+    /** For TPT: synthetic property representing the join to the parent table (child PK → parent PK). */
+    tptParentProp?: EntityProperty;
+    /** For TPT: inverse of tptParentProp, used for joining from parent to child (parent PK → child PK). */
+    tptInverseProp?: EntityProperty;
+    /** For TPT: virtual discriminator property name (computed at query time, not persisted). */
+    tptDiscriminatorColumn?: string;
+    /** For TPT: properties defined only in THIS entity (not inherited from parent). */
+    ownProps?: EntityProperty<Entity>[];
+    hasTriggers?: boolean;
+    /**
+     * Default ordering for this entity. Applied when querying this entity directly
+     * or when it's populated as a relation. Combined with other orderings based on precedence.
+     */
+    orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     /** @internal can be used for computed numeric cache keys */
     readonly _id: number;
 }
@@ -489,6 +733,7 @@ export interface CreateSchemaOptions {
 export interface ClearDatabaseOptions {
     schema?: string;
     truncate?: boolean;
+    clearIdentityMap?: boolean;
 }
 export interface EnsureDatabaseOptions extends CreateSchemaOptions, ClearDatabaseOptions {
     clear?: boolean;
@@ -516,25 +761,25 @@ export interface RefreshDatabaseOptions extends CreateSchemaOptions {
     createSchema?: boolean;
 }
 export interface ISchemaGenerator {
-    createSchema(options?: CreateSchemaOptions): Promise<void>;
-    ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
+    create(options?: CreateSchemaOptions): Promise<void>;
+    update(options?: UpdateSchemaOptions): Promise<void>;
+    drop(options?: DropSchemaOptions): Promise<void>;
+    refresh(options?: RefreshDatabaseOptions): Promise<void>;
+    clear(options?: ClearDatabaseOptions): Promise<void>;
+    execute(sql: string, options?: {
+        wrap?: boolean;
+    }): Promise<void>;
     getCreateSchemaSQL(options?: CreateSchemaOptions): Promise<string>;
-    dropSchema(options?: DropSchemaOptions): Promise<void>;
     getDropSchemaSQL(options?: Omit<DropSchemaOptions, 'dropDb'>): Promise<string>;
-    updateSchema(options?: UpdateSchemaOptions): Promise<void>;
     getUpdateSchemaSQL(options?: UpdateSchemaOptions): Promise<string>;
     getUpdateSchemaMigrationSQL(options?: UpdateSchemaOptions): Promise<{
         up: string;
         down: string;
     }>;
+    ensureDatabase(options?: EnsureDatabaseOptions): Promise<boolean>;
     createDatabase(name?: string): Promise<void>;
     dropDatabase(name?: string): Promise<void>;
-    execute(sql: string, options?: {
-        wrap?: boolean;
-    }): Promise<void>;
     ensureIndexes(): Promise<void>;
-    refreshDatabase(options?: RefreshDatabaseOptions): Promise<void>;
-    clearDatabase(options?: ClearDatabaseOptions): Promise<void>;
 }
 export type ImportsResolver = (alias: string, basePath: string, extension: '.js' | '', originFileName: string) => {
     path: string;
@@ -551,7 +796,10 @@ export interface GenerateOptions {
     undefinedDefaults?: boolean;
     bidirectionalRelations?: boolean;
     identifiedReferences?: boolean;
-    entitySchema?: boolean;
+    entityDefinition?: 'decorators' | 'defineEntity' | 'entitySchema';
+    decorators?: 'es' | 'legacy';
+    inferEntityType?: boolean;
+    enumMode?: 'ts-enum' | 'union-type' | 'dictionary';
     esmImport?: boolean;
     scalarTypeInDecorator?: boolean;
     scalarPropertiesForRelations?: 'always' | 'never' | 'smart';
@@ -570,7 +818,7 @@ export interface GenerateOptions {
 export interface IEntityGenerator {
     generate(options?: GenerateOptions): Promise<string[]>;
 }
-export type UmzugMigration = {
+export type MigrationInfo = {
     name: string;
     path?: string;
 };
@@ -590,6 +838,14 @@ export type MigrationRow = {
     name: string;
     executed_at: Date;
 };
+/**
+ * @internal
+ */
+export interface IMigrationRunner {
+    run(migration: Migration, method: 'up' | 'down'): Promise<void>;
+    setMasterMigration(trx: Transaction): void;
+    unsetMasterMigration(): void;
+}
 /**
  * @internal
  */
@@ -611,42 +867,42 @@ export interface IMigrator {
     /**
      * Checks current schema for changes, generates new migration if there are any.
      */
-    createMigration(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<MigrationResult>;
+    create(path?: string, blank?: boolean, initial?: boolean, name?: string): Promise<MigrationResult>;
     /**
      * Checks current schema for changes.
      */
-    checkMigrationNeeded(): Promise<boolean>;
+    checkSchema(): Promise<boolean>;
     /**
      * Creates initial migration. This generates the schema based on metadata, and checks whether all the tables
      * are already present. If yes, it will also automatically log the migration as executed.
      * Initial migration can be created only if the schema is already aligned with the metadata, or when no schema
      * is present - in such case regular migration would have the same effect.
      */
-    createInitialMigration(path?: string): Promise<MigrationResult>;
+    createInitial(path?: string): Promise<MigrationResult>;
     /**
      * Returns list of already executed migrations.
      */
-    getExecutedMigrations(): Promise<MigrationRow[]>;
+    getExecuted(): Promise<MigrationRow[]>;
     /**
      * Returns list of pending (not yet executed) migrations found in the migration directory.
      */
-    getPendingMigrations(): Promise<UmzugMigration[]>;
+    getPending(): Promise<MigrationInfo[]>;
     /**
      * Executes specified migrations. Without parameter it will migrate up to the latest version.
      */
-    up(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    up(options?: string | string[] | MigrateOptions): Promise<MigrationInfo[]>;
     /**
      * Executes down migrations to the given point. Without parameter it will migrate one version down.
      */
-    down(options?: string | string[] | MigrateOptions): Promise<UmzugMigration[]>;
+    down(options?: string | string[] | Omit<MigrateOptions, 'from'>): Promise<MigrationInfo[]>;
     /**
      * Registers event handler.
      */
-    on(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    on(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
     /**
      * Removes event handler.
      */
-    off(event: MigratorEvent, listener: (event: UmzugMigration) => MaybePromise<void>): IMigrator;
+    off(event: MigratorEvent, listener: (event: MigrationInfo) => MaybePromise<void>): IMigrator;
     /**
      * @internal
      */
@@ -674,17 +930,26 @@ export interface IMigrationGenerator {
 export interface Migration {
     up(): Promise<void> | void;
     down(): Promise<void> | void;
+    isTransactional(): boolean;
+    reset(): void;
+    setTransactionContext(ctx: Transaction): void;
+    getQueries?(): any[];
 }
 export interface MigrationObject {
     name: string;
     class: Constructor<Migration>;
 }
-export type FilterDef = {
+type EntityFromInput<T> = T extends readonly EntityName<infer U>[] ? U : T extends EntityName<infer U> ? U : never;
+type FilterDefResolved<T extends object = any> = {
     name: string;
-    cond: Dictionary | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<any, any, any, any> | FindOneOptions<any, any, any, any>) => Dictionary | Promise<Dictionary>);
+    cond: FilterQuery<T> | ((args: Dictionary, type: 'read' | 'update' | 'delete', em: any, options?: FindOptions<T, any, any, any> | FindOneOptions<T, any, any, any>, entityName?: string) => MaybePromise<FilterQuery<T>>);
     default?: boolean;
-    entity?: string[];
+    entity?: EntityName<T> | EntityName<T>[];
     args?: boolean;
+    strict?: boolean;
+};
+export type FilterDef<T extends EntityName | readonly EntityName[] = any> = FilterDefResolved<EntityFromInput<T>> & {
+    entity?: T;
 };
 export type Populate<T, P extends string = never> = readonly AutoPath<T, P, `${PopulatePath}`>[] | false;
 export type PopulateOptions<T> = {
@@ -692,48 +957,69 @@ export type PopulateOptions<T> = {
     strategy?: LoadStrategy;
     all?: boolean;
     filter?: boolean;
+    joinType?: 'inner join' | 'left join';
     children?: PopulateOptions<T[keyof T]>[];
+    /** When true, ignores `mapToPk` on the property and returns full entity data instead of just PKs. */
+    dataOnly?: boolean;
+};
+export type PopulateHintOptions = {
+    strategy?: LoadStrategy.JOINED | LoadStrategy.SELECT_IN | 'joined' | 'select-in';
+    joinType?: 'inner join' | 'left join';
 };
-type Loadable<T extends object> = Collection<T, any> | Reference<T> | Ref<T> | readonly T[];
-type ExtractType<T> = T extends Loadable<infer U> ? U : T;
+type ExtractType<T> = T extends CollectionShape<infer U> ? U : T extends ReferenceShape<infer U> ? U : T extends Ref<infer U> ? U : T extends readonly (infer U)[] ? U : T;
 type ExtractStringKeys<T> = {
-    [K in keyof T]: CleanKeys<T, K>;
+    [K in keyof T]-?: CleanKeys<T, K>;
 }[keyof T] & {};
-type StringKeys<T, E extends string = never> = T extends Collection<any, any> ? ExtractStringKeys<ExtractType<T>> | E : T extends Reference<any> ? ExtractStringKeys<ExtractType<T>> | E : T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
+/**
+ * Extracts string keys from an entity type, handling Collection/Reference wrappers.
+ * Simplified to just check `T extends object` since ExtractType handles the unwrapping.
+ */
+type StringKeys<T, E extends string = never> = T extends object ? ExtractStringKeys<ExtractType<T>> | E : never;
 type GetStringKey<T, K extends StringKeys<T, string>, E extends string> = K extends keyof T ? ExtractType<T[K]> : (K extends E ? keyof T : never);
 type Prev = [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-type CollectionKeys<T> = T extends object ? {
-    [K in keyof T]: T[K] extends Collection<any> ? IsAny<T[K]> extends true ? never : K & string : never;
+type RelationKeys<T> = T extends object ? {
+    [K in keyof T]-?: CleanKeys<T, K, true>;
 }[keyof T] & {} : never;
-export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? (P & `${string}.` extends never ? P : P & `${string}.`) extends infer Q ? Q extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : Q extends StringKeys<O, E> ? (NonNullable<GetStringKey<O, Q, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<NonNullable<GetStringKey<O, Q, E>>, E> extends never ? never : `${Q & string}.`) : StringKeys<O, E> | `${CollectionKeys<O>}:ref` : never : never : never;
+export type AutoPath<O, P extends string | boolean, E extends string = never, D extends Prev[number] = 9> = P extends boolean ? P : [D] extends [never] ? never : P extends any ? P extends string ? P extends `${infer A}.${infer B}` ? A extends StringKeys<O, E> ? `${A}.${AutoPath<NonNullable<GetStringKey<O, A, E>>, B, E, Prev[D]>}` : never : P extends StringKeys<O, E> ? (NonNullable<GetStringKey<O, P & StringKeys<O, E>, E>> extends unknown ? Exclude<P, `${string}.`> : never) | (StringKeys<NonNullable<GetStringKey<O, P & StringKeys<O, E>, E>>, E> extends never ? never : `${P & string}.`) : StringKeys<O, E> | `${RelationKeys<O>}:ref` : never : never;
 export type UnboxArray<T> = T extends any[] ? ArrayElement<T> : T;
 export type ArrayElement<ArrayType extends unknown[]> = ArrayType extends (infer ElementType)[] ? ElementType : never;
-export type ExpandProperty<T> = T extends Reference<infer U> ? NonNullable<U> : T extends Collection<infer U, any> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
-type LoadedLoadable<T, E extends object> = T extends Collection<any, any> ? LoadedCollection<E> : T extends Reference<any> ? T & LoadedReference<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends Scalar | any[] ? T : E;
+export type ExpandProperty<T> = T extends ReferenceShape<infer U> ? NonNullable<U> : T extends CollectionShape<infer U> ? NonNullable<U> : T extends (infer U)[] ? NonNullable<U> : NonNullable<T>;
+type LoadedLoadable<T, E extends object> = T extends CollectionShape ? LoadedCollection<E> : T extends ScalarReference<infer U> ? LoadedScalarReference<U> : T extends ReferenceShape ? T & LoadedReference<E> : T extends Scalar ? T : T extends (infer U)[] ? U extends Scalar ? T : E[] : E;
 type IsTrue<T> = IsNever<T> extends true ? false : T extends boolean ? T extends true ? true : false : false;
 type StringLiteral<T> = T extends string ? string extends T ? never : T : never;
 type Prefix<T, K> = K extends `${infer S}.${string}` ? S : (K extends '*' ? keyof T : K);
 type IsPrefixedExclude<T, K extends keyof T, E extends string> = K extends E ? never : K;
-export type IsPrefixed<T, K extends keyof T, L extends string, E extends string = never> = IsNever<E> extends false ? IsPrefixedExclude<T, K, E> : K extends symbol ? never : IsTrue<L> extends true ? (T[K] & {} extends Loadable<any> ? K : never) : IsNever<StringLiteral<L>> extends true ? never : K extends Prefix<T, L> ? K : K extends PrimaryProperty<T> ? K : never;
+export type IsPrefixed<T, K extends keyof T, L extends string, E extends string = never> = IsNever<E> extends false ? IsPrefixedExclude<T, K, E> : K extends symbol ? never : IsTrue<L> extends true ? (T[K] & {} extends LoadableShape ? K : never) : IsNever<StringLiteral<L>> extends true ? never : '*' extends L ? K : K extends Prefix<T, L> ? K : K extends PrimaryProperty<T> ? K : never;
 type Suffix<Key, Hint extends string, All = true | '*'> = Hint extends `${infer Pref}.${infer Suf}` ? (Pref extends Key ? Suf : never) : Hint extends All ? Hint : never;
-export type IsSubset<T, U> = keyof U extends keyof T ? {} : Dictionary extends U ? {} : {
+export type IsSubset<T, U> = keyof U extends keyof T ? {} : string extends keyof U ? {} : {
     [K in keyof U as K extends keyof T ? never : CleanKeys<U, K>]: never;
 };
-declare const __selectedType: unique symbol;
-declare const __loadedType: unique symbol;
-type AnyStringToNever<T> = string extends T ? never : T;
-export type MergeSelected<T, U, F extends string> = T extends Loaded<infer TT, infer P, infer FF, infer E> ? IsNever<Exclude<E, F>> extends true ? Loaded<TT, P, AnyStringToNever<F> | AnyStringToNever<FF>> : Loaded<TT, AnyStringToNever<P>, AnyStringToNever<FF>, AnyStringToNever<Exclude<E, F>>> : T;
-type MergeFields<F1 extends string, F2 extends string, P1, P2> = P1 | P2 extends '*' ? '*' : F1 | F2;
-type MergeExcludes<F extends string, E extends string> = F extends E ? never : Exclude<E, F>;
-export type MergeLoaded<T, U, P extends string, F extends string, E extends string, R extends boolean = false> = T extends Loaded<U, infer PP, infer FF, infer EE> ? string extends FF ? Loaded<T, P, F, AnyStringToNever<EE> | E> : string extends P ? Loaded<U, never, F | (FF & string), MergeExcludes<F | (FF & string), EE | E>> : Loaded<U, P | AnyStringToNever<PP>, MergeFields<F, AnyStringToNever<FF>, P, PP>, MergeExcludes<MergeFields<F, AnyStringToNever<FF>, P, PP>, (R extends true ? never : EE) | E>> : Loaded<T, P, F>;
-type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
+/**
+ * Fast check if T is a Loaded type by looking for the marker symbol.
+ * This is much cheaper than matching against the full Loaded structure.
+ */
+type IsLoadedType<T> = T extends {
+    [__loadedType]?: any;
+} ? true : false;
+/**
+ * Optimized MergeSelected using intersection instead of extraction.
+ * When T is already Loaded, we intersect with a new Loaded type for the selected fields.
+ * This avoids the expensive pattern matching needed to extract hints from Loaded types.
+ */
+export type MergeSelected<T, U, F extends string> = IsLoadedType<T> extends true ? T & Loaded<U, never, F, never> : T;
+/**
+ * Optimized MergeLoaded using intersection instead of extraction.
+ * When T is already Loaded, we intersect with a new Loaded type for the additional hints.
+ * This avoids the expensive pattern matching needed to extract hints from Loaded types.
+ * Used for `em.populate` and `em.refresh`.
+ */
+export type MergeLoaded<T, U, P extends string, F extends string, E extends string, R extends boolean = false> = IsLoadedType<T> extends true ? T & Loaded<U, P, F, E> : Loaded<T, P, F, E>;
+export type AddOptional<T> = undefined | null extends T ? null | undefined : null extends T ? null : undefined extends T ? undefined : never;
 type LoadedProp<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedLoadable<T, Loaded<ExtractType<T>, L, F, E>>;
 export type AddEager<T> = ExtractEagerProps<T> & string;
 export type ExpandHint<T, L extends string> = L | AddEager<T>;
 export type Selected<T, L extends string = never, F extends string = '*'> = {
-    [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
-} & {
-    [K in keyof T as FunctionKeys<T, K>]: T[K];
+    [K in keyof T as IsPrefixed<T, K, L | F | AddEager<T>> | FunctionKeys<T, K>]: T[K] extends Function ? T[K] : NonNullable<T[K]> extends Scalar ? T[K] : LoadedProp<NonNullable<T[K]>, Suffix<K, L, true>, Suffix<K, F, true>> | AddOptional<T[K]>;
 } & {
     [__selectedType]?: T;
 };
@@ -744,18 +1030,18 @@ type LoadedEntityType<T> = {
 };
 export type EntityType<T> = T | LoadedEntityType<T>;
 export type FromEntityType<T> = T extends LoadedEntityType<infer U> ? U : T;
-type LoadedInternal<T, L extends string = never, F extends string = '*', E extends string = never> = [
-    F
-] extends ['*'] ? IsNever<E> extends true ? T & {
+type LoadedInternal<T, L extends string = never, F extends string = '*', E extends string = never> = [F] extends ['*'] ? IsNever<E> extends true ? T & {
     [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
 } : {
     [K in keyof T as IsPrefixed<T, K, ExpandHint<T, L>, E>]: LoadedProp<NonNullable<T[K]>, Suffix<K, L>, Suffix<K, F>, Suffix<K, E>> | AddOptional<T[K]>;
 } : Selected<T, L, F>;
 /**
  * Represents entity with its loaded relations (`populate` hint) and selected properties (`fields` hint).
+ * The __loadHint marker uses contravariance to ensure Loaded<A, 'b'> is NOT assignable to Loaded<A, 'b.c'>.
  */
 export type Loaded<T, L extends string = never, F extends string = '*', E extends string = never> = LoadedInternal<T, L, F, E> & {
     [__loadedType]?: T;
+    [__loadHint]?: (hint: Prefixes<L>) => void;
 };
 export interface LoadedReference<T> extends Reference<NonNullable<T>> {
     $: NonNullable<T>;
@@ -775,23 +1061,23 @@ export interface Highlighter {
     highlight(text: string): string;
 }
 export interface IMetadataStorage {
-    getAll(): Dictionary<EntityMetadata>;
-    get<T = any>(entity: string, init?: boolean, validate?: boolean): EntityMetadata<T>;
-    find<T = any>(entity: string): EntityMetadata<T> | undefined;
-    has(entity: string): boolean;
-    set(entity: string, meta: EntityMetadata): EntityMetadata;
-    reset(entity: string): void;
+    getAll(): Map<EntityName, EntityMetadata>;
+    get<T = any>(entity: EntityName<T>, init?: boolean, validate?: boolean): EntityMetadata<T>;
+    find<T = any>(entity: EntityName<T>): EntityMetadata<T> | undefined;
+    has<T>(entity: EntityName<T>): boolean;
+    set<T>(entity: EntityName<T>, meta: EntityMetadata): EntityMetadata;
+    reset<T>(entity: EntityName<T>): void;
 }
 export interface IHydrator {
     /**
      * Hydrates the whole entity. This process handles custom type conversions, creating missing Collection instances,
      * mapping FKs to entity instances, as well as merging those entities.
      */
-    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    hydrate<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, type: 'full' | 'reference', newEntity?: boolean, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
     /**
      * Hydrates primary keys only
      */
-    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string): void;
+    hydrateReference<T extends object>(entity: T, meta: EntityMetadata<T>, data: EntityData<T>, factory: EntityFactory, convertCustomTypes?: boolean, schema?: string, parentSchema?: string, normalizeAccessors?: boolean): void;
     isRunning(): boolean;
 }
 export interface HydratorConstructor {
@@ -801,17 +1087,25 @@ export interface ISeedManager {
     seed(...classNames: Constructor<Seeder>[]): Promise<void>;
     /** @internal */
     seedString(...classNames: string[]): Promise<void>;
-    createSeeder(className: string): Promise<string>;
+    create(className: string): Promise<string>;
 }
 export interface Seeder<T extends Dictionary = Dictionary> {
     run(em: EntityManager, context?: T): void | Promise<void>;
 }
+export interface SeederObject {
+    name: string;
+    class: Constructor<Seeder>;
+}
 export type ConnectionType = 'read' | 'write';
 export type MetadataProcessor = (metadata: EntityMetadata[], platform: Platform) => MaybePromise<void>;
-/**
- * The type of context that the user intends to inject.
- */
-export type ContextProvider<T> = MaybePromise<MikroORM> | ((type: T) => MaybePromise<MikroORM | EntityManager | EntityRepository<any> | {
-    getEntityManager(): EntityManager;
-}>);
-export {};
+export type MaybeReturnType<T> = T extends (...args: any[]) => infer R ? R : T;
+export interface EntitySchemaWithMeta<TName extends string = string, TTableName extends string = string, TEntity = any, TBase = never, TProperties extends Record<string, any> = Record<string, any>, TClass extends EntityCtor = EntityCtor<TEntity>> extends EntitySchema<TEntity, TBase, TClass> {
+    readonly name: TName;
+    readonly properties: TProperties;
+    readonly tableName: TTableName;
+    /** @internal Direct entity type access - avoids expensive pattern matching */
+    readonly '~entity': TEntity;
+}
+export type InferEntity<Schema> = Schema extends {
+    '~entity': infer E;
+} ? E : Schema extends EntitySchema<infer Entity> ? Entity : Schema extends EntityClass<infer Entity> ? Entity : Schema;