@mikro-orm/core 7.0.0-dev.323 → 7.0.0-dev.325

package/MikroORM.d.ts

@@ -5,7 +5,7 @@ import { Configuration, type Options } from './utils/Configuration.js';
 import type { EntityManager } from './EntityManager.js';
 import type { AnyEntity, Constructor, EntityClass, EntityMetadata, EntityName, IEntityGenerator, IMigrator, ISeedManager } from './typings.js';
 /** @internal */
-export declare function loadOptionalDependencies(options: Options): Promise<void>;
+export declare function loadOptionalDependencies(options: Partial<Options>): Promise<void>;
 /**
  * The main class used to configure and bootstrap the ORM.
  *
@@ -46,14 +46,14 @@ export declare class MikroORM<Driver extends IDatabaseDriver = IDatabaseDriver,
      * Initialize the ORM, load entity metadata, create EntityManager and connect to the database.
      * If you omit the `options` parameter, your CLI config will be used.
      */
-    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Promise<MikroORM<D, EM, Entities>>;
+    static init<D extends IDatabaseDriver = IDatabaseDriver, EM extends D[typeof EntityManagerType] & EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Promise<MikroORM<D, EM, Entities>>;
     /**
      * Synchronous variant of the `init` method with some limitations:
      * - folder-based discovery not supported
      * - ORM extensions are not autoloaded
      * - when metadata cache is enabled, `FileCacheAdapter` needs to be explicitly set in the config
      */
-    constructor(options: Options<Driver, EM, Entities>);
+    constructor(options: Partial<Options<Driver, EM, Entities>>);
     /**
      * Connects to the database.
      */

package/entity/WrappedEntity.d.ts

@@ -8,6 +8,8 @@ import type { EntityIdentifier } from './EntityIdentifier.js';
 import type { SerializationContext } from '../serialization/SerializationContext.js';
 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';
 export declare class WrappedEntity<Entity extends object> {
     __initialized: boolean;
     __populated?: boolean;
@@ -58,7 +60,7 @@ export declare class WrappedEntity<Entity extends object> {
     setPrimaryKey(id: Primary<Entity> | null): void;
     getSerializedPrimaryKey(): string;
     get __meta(): EntityMetadata<Entity>;
-    get __platform(): import("../index.js").Platform;
-    get __config(): import("../index.js").Configuration<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>, EntityManager<import("../drivers/IDatabaseDriver.js").IDatabaseDriver<import("../index.js").Connection>>>;
+    get __platform(): Platform;
+    get __config(): Configuration;
     get __primaryKeys(): Primary<Entity>[];
 }

package/entity/defineEntity.d.ts

@@ -508,48 +508,35 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
 type EntityTarget = {
     '~entity': any;
 } | EntityClass;
-declare const propertyBuilders: {
-    bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
-    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
-    decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
+declare const propertyBuilders: PropertyBuilders;
+type PropertyBuildersOverrideKeys = 'bigint' | 'array' | 'decimal' | 'json' | 'datetime' | 'time' | 'enum';
+export type PropertyBuilders = {
+    [K in Exclude<keyof typeof types, PropertyBuildersOverrideKeys>]: () => UniversalPropertyOptionsBuilder<InferPropertyValueType<(typeof types)[K]>, EmptyOptions, IncludeKeysForProperty>;
+} & {
+    bigint: <Mode extends 'bigint' | 'number' | 'string' = 'bigint'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.bigint<Mode>>, EmptyOptions, IncludeKeysForProperty>;
+    array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.array<T>>, EmptyOptions, IncludeKeysForProperty>;
+    decimal: <Mode extends 'number' | 'string' = 'string'>(mode?: Mode) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.decimal<Mode>>, EmptyOptions, IncludeKeysForProperty>;
     json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
     formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-    datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
-    time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
+    datetime: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.datetime>, EmptyOptions, IncludeKeysForProperty>;
+    time: (length?: number) => UniversalPropertyOptionsBuilder<InferPropertyValueType<typeof types.time>, EmptyOptions, IncludeKeysForProperty>;
     type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
     enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
     embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "embedded";
+        kind: 'embedded';
     }>;
     manyToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-        kind: "m:n";
+        kind: 'm:n';
     }>;
     manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "m:1";
+        kind: 'm:1';
     }>;
     oneToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-        kind: "1:m";
+        kind: '1:m';
     }>;
     oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-        kind: "1:1";
+        kind: '1:1';
     }>;
-    date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
-    uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
-    enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
-    integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    smallint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    tinyint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    mediumint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    float: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-    double: () => UniversalPropertyOptionsBuilder<NonNullable<string | number>, EmptyOptions, IncludeKeysForProperty>;
-    boolean: () => UniversalPropertyOptionsBuilder<NonNullable<boolean | null | undefined>, EmptyOptions, IncludeKeysForProperty>;
-    character: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    string: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    uuid: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    text: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-    unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
 };
 /** 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);
@@ -559,7 +546,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     extends?: {
         '~entity': TBase;
     } | EntityCtor<TBase>;
-    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
@@ -595,53 +582,11 @@ export declare function defineEntity<const TEntity = any, const TProperties exte
     className?: TClassName;
     tableName?: TTableName;
     extends?: TBase;
-    properties: TProperties | ((properties: typeof propertyBuilders) => TProperties);
+    properties: TProperties | ((properties: PropertyBuilders) => TProperties);
     hooks?: DefineEntityHooks<TEntity>;
 }): EntitySchemaWithMeta<TClassName, TTableName, TEntity, TBase, TProperties, TClass>;
 export declare namespace defineEntity {
-    var properties: {
-        bigint: <Mode extends "bigint" | "number" | "string" = "bigint">(mode?: Mode) => UniversalPropertyOptionsBuilder<(Mode extends "bigint" ? bigint : Mode extends "number" ? number : string) & {}, EmptyOptions, IncludeKeysForProperty>;
-        array: <T = string>(toJsValue?: (i: string) => T, toDbValue?: (i: T) => string) => UniversalPropertyOptionsBuilder<T[], EmptyOptions, IncludeKeysForProperty>;
-        decimal: <Mode extends "number" | "string" = "string">(mode?: Mode) => UniversalPropertyOptionsBuilder<NonNullable<Mode extends "number" ? number : string>, EmptyOptions, IncludeKeysForProperty>;
-        json: <T>() => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        formula: <T>(formula: string | FormulaCallback<any>) => UniversalPropertyOptionsBuilder<T, EmptyOptions, IncludeKeysForProperty>;
-        datetime: (length?: number) => UniversalPropertyOptionsBuilder<Date, EmptyOptions, IncludeKeysForProperty>;
-        time: (length?: number) => UniversalPropertyOptionsBuilder<any, EmptyOptions, IncludeKeysForProperty>;
-        type: <T extends PropertyValueType>(type: T) => UniversalPropertyOptionsBuilder<InferPropertyValueType<T>, EmptyOptions, IncludeKeysForProperty>;
-        enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => UniversalPropertyOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T, EmptyOptions, IncludeKeysForEnumOptions>;
-        embedded: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "embedded";
-        }>;
-        manyToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-            kind: "m:n";
-        }>;
-        manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "m:1";
-        }>;
-        oneToMany: <Target extends EntityTarget>(target: Target) => PropertyChain<InferEntity<Target>, EmptyOptions & {
-            kind: "1:m";
-        }>;
-        oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
-            kind: "1:1";
-        }>;
-        date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
-        uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
-        enumArray: () => UniversalPropertyOptionsBuilder<(string | number)[], EmptyOptions, IncludeKeysForProperty>;
-        integer: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        smallint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        tinyint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        mediumint: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        float: () => UniversalPropertyOptionsBuilder<number, EmptyOptions, IncludeKeysForProperty>;
-        double: () => UniversalPropertyOptionsBuilder<NonNullable<string | number>, EmptyOptions, IncludeKeysForProperty>;
-        boolean: () => UniversalPropertyOptionsBuilder<NonNullable<boolean | null | undefined>, EmptyOptions, IncludeKeysForProperty>;
-        character: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        string: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        uuid: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        text: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        interval: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
-        unknown: () => UniversalPropertyOptionsBuilder<{}, EmptyOptions, IncludeKeysForProperty>;
-    };
+    var properties: PropertyBuilders;
 }
 export { propertyBuilders as p };
 type EntityHookValue<T, K extends keyof EventSubscriber<T>> = (keyof T | NonNullable<EventSubscriber<T>[K]>)[];

package/errors.d.ts

@@ -56,17 +56,17 @@ export declare class MetadataError<T extends AnyEntity = AnyEntity> extends Vali
     static duplicateFieldName(entityName: EntityName, names: [string, string][]): MetadataError;
     static multipleDecorators(entityName: string, propertyName: string): MetadataError;
     static missingMetadata(entity: string): MetadataError;
-    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError<Partial<any>>;
-    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError<Partial<any>>;
-    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError<Partial<any>>;
-    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError<Partial<any>>;
-    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
-    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
-    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError<Partial<any>>;
-    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError<Partial<any>>;
-    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError<Partial<any>>;
+    static invalidPrimaryKey(meta: EntityMetadata, prop: EntityProperty, requiredName: string): MetadataError;
+    static invalidManyToManyWithPivotEntity(meta1: EntityMetadata, prop1: EntityProperty, meta2: EntityMetadata, prop2: EntityProperty): MetadataError;
+    static targetIsAbstract(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static nonPersistentCompositeProp(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static propertyTargetsEntityType(meta: EntityMetadata, prop: EntityProperty, target: EntityMetadata): MetadataError;
+    static fromMissingOption(meta: EntityMetadata, prop: EntityProperty, option: string): MetadataError;
+    static targetKeyOnManyToMany(meta: EntityMetadata, prop: EntityProperty): MetadataError;
+    static targetKeyNotUnique(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
+    static targetKeyNotFound(meta: EntityMetadata, prop: EntityProperty, target?: EntityMetadata): MetadataError;
+    static incompatiblePolymorphicTargets(meta: EntityMetadata, prop: EntityProperty, target1: EntityMetadata, target2: EntityMetadata, reason: string): MetadataError;
+    static dangerousPropertyName(meta: EntityMetadata, prop: EntityProperty): MetadataError;
     static viewEntityWithoutExpression(meta: EntityMetadata): MetadataError;
     static mixedInheritanceStrategies(root: EntityMetadata, child: EntityMetadata): MetadataError;
     static tptNotSupportedByDriver(meta: EntityMetadata): MetadataError;

package/logging/colors.js

@@ -2,7 +2,7 @@ import { getEnv } from '../utils/env-vars.js';
 const bool = (k) => ['true', 't', '1'].includes(getEnv(k)?.toLowerCase() ?? '');
 const boolIfDefined = (k) => (getEnv(k) != null ? bool(k) : true);
 const enabled = () => !bool('NO_COLOR') && !bool('MIKRO_ORM_NO_COLOR') && boolIfDefined('FORCE_COLOR') && boolIfDefined('MIKRO_ORM_COLORS');
-const wrap = (fn) => (text) => (enabled() ? fn(text) : text);
+const wrap = (fn) => (text) => enabled() ? fn(text) : text;
 /** @internal */
 export const colors = {
     red: wrap((text) => `\x1B[31m${text}\x1B[39m`),

package/metadata/EntitySchema.d.ts

@@ -47,7 +47,7 @@ export declare class EntitySchema<Entity = any, Base = never, Class extends Enti
      * When schema links the entity class via `class` option, this registry allows the lookup from opposite side,
      * so we can use the class in `entities` option just like the EntitySchema instance.
      */
-    static REGISTRY: Map<Partial<any>, EntitySchema<any, never, EntityCtor<any>>>;
+    static REGISTRY: Map<AnyEntity, EntitySchema>;
     /** @internal Type-level marker for fast entity type inference */
     readonly '~entity': Entity;
     private readonly _meta;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "7.0.0-dev.323",
+  "version": "7.0.0-dev.325",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "keywords": [
     "data-mapper",

package/serialization/SerializationContext.d.ts

@@ -7,7 +7,7 @@ import type { AnyEntity, EntityMetadata, EntityName, PopulateOptions } from '../
 export declare class SerializationContext<T extends object> {
     #private;
     readonly path: [EntityName, string][];
-    readonly visited: Set<Partial<any>>;
+    readonly visited: Set<AnyEntity>;
     constructor(populate?: PopulateOptions<T>[], fields?: Set<string>, exclude?: readonly string[]);
     /**
      * Returns true when there is a cycle detected.

package/utils/Configuration.d.ts

@@ -2,8 +2,6 @@ import type { NamingStrategy } from '../naming-strategy/NamingStrategy.js';
 import { type CacheAdapter, type SyncCacheAdapter } from '../cache/CacheAdapter.js';
 import type { EntityRepository } from '../entity/EntityRepository.js';
 import type { AnyEntity, CompiledFunctions, Constructor, Dictionary, EnsureDatabaseOptions, EntityClass, EntityMetadata, FilterDef, GenerateOptions, Highlighter, HydratorConstructor, IHydrator, IMigrationGenerator, IPrimaryKey, MaybePromise, Migration, MigrationObject, Seeder, SeederObject } from '../typings.js';
-import { ObjectHydrator } from '../hydration/ObjectHydrator.js';
-import { NullHighlighter } from '../utils/NullHighlighter.js';
 import { type Logger, type LoggerNamespace, type LoggerOptions } from '../logging/Logger.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -13,143 +11,27 @@ import type { MetadataStorage } from '../metadata/MetadataStorage.js';
 import type { EventSubscriber } from '../events/EventSubscriber.js';
 import type { AssignOptions } from '../entity/EntityAssigner.js';
 import type { EntityManagerType, IDatabaseDriver } from '../drivers/IDatabaseDriver.js';
-import { NotFoundError } from '../errors.js';
 import { DataloaderType, FlushMode, LoadStrategy, PopulateHint, type EmbeddedPrefixMode } from '../enums.js';
-import { MemoryCacheAdapter } from '../cache/MemoryCacheAdapter.js';
 import { EntityComparator } from './EntityComparator.js';
 import type { Type } from '../types/Type.js';
 import type { MikroORM } from '../MikroORM.js';
-declare const DEFAULTS: {
-    readonly pool: {};
-    readonly entities: readonly [];
-    readonly entitiesTs: readonly [];
-    readonly extensions: readonly [];
-    readonly subscribers: readonly [];
-    readonly filters: {};
-    readonly discovery: {
-        readonly warnWhenNoEntities: true;
-        readonly checkDuplicateTableNames: true;
-        readonly checkDuplicateFieldNames: true;
-        readonly checkDuplicateEntities: true;
-        readonly checkNonPersistentCompositeProps: true;
-        readonly inferDefaultValues: true;
-    };
-    readonly validateRequired: true;
-    readonly context: (name: string) => EntityManager<IDatabaseDriver<import("../index.js").Connection>> | undefined;
-    readonly contextName: "default";
-    readonly allowGlobalContext: false;
-    readonly logger: (message?: any, ...optionalParams: any[]) => void;
-    readonly colors: true;
-    readonly findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
-    readonly findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => NotFoundError<Partial<any>>;
-    readonly baseDir: string;
-    readonly hydrator: typeof ObjectHydrator;
-    readonly flushMode: FlushMode.AUTO;
-    readonly loadStrategy: LoadStrategy.BALANCED;
-    readonly dataloader: DataloaderType.NONE;
-    readonly populateWhere: PopulateHint.ALL;
-    readonly ignoreUndefinedInQuery: false;
-    readonly onQuery: (sql: string) => string;
-    readonly autoJoinOneToOneOwner: true;
-    readonly autoJoinRefsForFilters: true;
-    readonly filtersOnRelations: true;
-    readonly propagationOnPrototype: true;
-    readonly populateAfterFlush: true;
-    readonly serialization: {
-        readonly includePrimaryKeys: true;
-    };
-    readonly assign: {
-        readonly updateNestedEntities: true;
-        readonly updateByPrimaryKey: true;
-        readonly mergeObjectProperties: false;
-        readonly mergeEmbeddedProperties: true;
-        readonly ignoreUndefined: false;
-    };
-    readonly persistOnCreate: true;
-    readonly upsertManaged: true;
-    readonly forceEntityConstructor: false;
-    readonly forceUndefined: false;
-    readonly forceUtcTimezone: true;
-    readonly processOnCreateHooksEarly: true;
-    readonly ensureDatabase: true;
-    readonly ensureIndexes: false;
-    readonly batchSize: 300;
-    readonly debug: false;
-    readonly ignoreDeprecations: false;
-    readonly verbose: false;
-    readonly driverOptions: {};
-    readonly migrations: {
-        readonly tableName: "mikro_orm_migrations";
-        readonly glob: "!(*.d).{js,ts,cjs}";
-        readonly silent: false;
-        readonly transactional: true;
-        readonly allOrNothing: true;
-        readonly dropTables: true;
-        readonly safe: false;
-        readonly snapshot: true;
-        readonly emit: "ts";
-        readonly fileName: (timestamp: string, name?: string) => string;
-    };
-    readonly schemaGenerator: {
-        readonly createForeignKeyConstraints: true;
-        readonly ignoreSchema: readonly [];
-        readonly skipTables: readonly [];
-        readonly skipViews: readonly [];
-        readonly skipColumns: {};
-    };
-    readonly embeddables: {
-        readonly prefixMode: "relative";
-    };
-    readonly entityGenerator: {
-        readonly forceUndefined: true;
-        readonly undefinedDefaults: false;
-        readonly scalarTypeInDecorator: false;
-        readonly bidirectionalRelations: true;
-        readonly identifiedReferences: true;
-        readonly scalarPropertiesForRelations: "never";
-        readonly entityDefinition: "defineEntity";
-        readonly decorators: "legacy";
-        readonly enumMode: "dictionary";
-        readonly fileName: (className: string) => string;
-        readonly onlyPurePivotTables: false;
-        readonly outputPurePivotTables: false;
-        readonly readOnlyPivotTables: false;
-        readonly useCoreBaseEntity: false;
-    };
-    readonly metadataCache: {};
-    readonly resultCache: {
-        readonly adapter: typeof MemoryCacheAdapter;
-        readonly expiration: 1000;
-        readonly options: {};
-    };
-    readonly metadataProvider: typeof MetadataProvider;
-    readonly highlighter: NullHighlighter;
-    readonly seeder: {
-        readonly defaultSeeder: "DatabaseSeeder";
-        readonly glob: "!(*.d).{js,ts}";
-        readonly emit: "ts";
-        readonly fileName: (className: string) => string;
-    };
-    readonly preferReadReplicas: true;
-    readonly dynamicImportProvider: (id: string) => Promise<any>;
-};
 export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = D[typeof EntityManagerType] & EntityManager<D>> {
     #private;
-    constructor(options: Options, validate?: boolean);
+    constructor(options: Partial<Options>, validate?: boolean);
     getPlatform(): ReturnType<D['getPlatform']>;
     /**
      * Gets specific configuration option. Falls back to specified `defaultValue` if provided.
      */
-    get<T extends keyof Options<D, EM>, U extends RequiredOptions<D, EM>[T]>(key: T, defaultValue?: U): U;
-    getAll(): RequiredOptions<D, EM>;
+    get<T extends keyof Options<D, EM>, U extends Options<D, EM>[T]>(key: T, defaultValue?: U): U;
+    getAll(): Options<D, EM>;
     /**
      * Overrides specified configuration value.
      */
-    set<T extends keyof Options<D, EM>, U extends RequiredOptions<D, EM>[T]>(key: T, value: U): void;
+    set<T extends keyof Options<D, EM>, U extends Options<D, EM>[T]>(key: T, value: U): void;
     /**
      * Resets the configuration to its default value
      */
-    reset<T extends keyof RequiredOptions<D, EM>>(key: T): void;
+    reset<T extends keyof Options<D, EM>>(key: T): void;
     /**
      * Gets Logger instance.
      */
@@ -204,7 +86,7 @@ export declare class Configuration<D extends IDatabaseDriver = IDatabaseDriver,
 /**
  * Type helper to make it easier to use `mikro-orm.config.js`.
  */
-export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Options<D, EM, Entities>): Options<D, EM, Entities>;
+export declare function defineConfig<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]>(options: Partial<Options<D, EM, Entities>>): Partial<Options<D, EM, Entities>>;
 /**
  * Connection configuration options for database connections.
  * @see https://mikro-orm.io/docs/configuration#connection
@@ -458,6 +340,13 @@ export interface MetadataDiscoveryOptions {
  * @see https://mikro-orm.io/docs/configuration
  */
 export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<Driver> & Driver[typeof EntityManagerType] = EntityManager<Driver> & Driver[typeof EntityManagerType], Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> extends ConnectionOptions {
+    /** Connection pool configuration. */
+    pool: PoolConfig;
+    /**
+     * Additional driver-specific options.
+     * The object will be deeply merged with internal driver options.
+     */
+    driverOptions: Dictionary;
     /**
      * Array of entity classes or paths to entity modules.
      * Paths support glob patterns for automatic discovery.
@@ -465,7 +354,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * entities: [Author, Book, Publisher] // class references
      * entities: ['./dist/entities'] // folder paths
      */
-    entities?: Entities;
+    entities: Entities;
     /**
      * Array of TypeScript entity source paths.
      * Used when running in TypeScript mode (e.g., via `tsx` or `swc`).
@@ -473,34 +362,34 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @example
      * entitiesTs: ['./src/entities']
      */
-    entitiesTs?: Entities;
+    entitiesTs: Entities;
     /**
      * ORM extensions to register (e.g., Migrator, EntityGenerator, SeedManager).
      * Extensions registered here are available via shortcuts like `orm.migrator`.
      * @example
      * extensions: [Migrator, EntityGenerator, SeedManager]
      */
-    extensions?: {
+    extensions: {
         register: (orm: MikroORM) => void;
     }[];
     /**
      * Event subscribers to register.
      * Can be class references or instances.
      */
-    subscribers?: Iterable<EventSubscriber | Constructor<EventSubscriber>>;
+    subscribers: Iterable<EventSubscriber | Constructor<EventSubscriber>>;
     /**
      * Global entity filters to apply.
      * Filters are applied by default unless explicitly disabled.
      * @see https://mikro-orm.io/docs/filters
      */
-    filters?: Dictionary<{
+    filters: Dictionary<{
         name?: string;
     } & Omit<FilterDef, 'name'>>;
     /**
      * Metadata discovery configuration options.
      * Controls how entities are discovered and validated.
      */
-    discovery?: MetadataDiscoveryOptions;
+    discovery: MetadataDiscoveryOptions;
     /**
      * Database driver class to use.
      * Should be imported from the specific driver package (e.g. `@mikro-orm/mysql`, `@mikro-orm/postgresql`).
@@ -540,7 +429,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Enable verbose logging of internal operations.
      * @default false
      */
-    verbose?: boolean;
+    verbose: boolean;
     /**
      * Ignore `undefined` values in find queries instead of treating them as `null`.
      * @default false
@@ -548,7 +437,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * // With ignoreUndefinedInQuery: true
      * em.find(User, { email: undefined }) // resolves to em.find(User, {})
      */
-    ignoreUndefinedInQuery?: boolean;
+    ignoreUndefinedInQuery: boolean;
     /**
      * Hook to modify SQL queries before execution.
      * Useful for adding observability hints or query modifications.
@@ -556,38 +445,38 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @param params - Query parameters
      * @returns Modified SQL query
      */
-    onQuery?: (sql: string, params: readonly unknown[]) => string;
+    onQuery: (sql: string, params: readonly unknown[]) => string;
     /**
      * Automatically join the owning side of 1:1 relations when querying the inverse side.
      * @default true
      */
-    autoJoinOneToOneOwner?: boolean;
+    autoJoinOneToOneOwner: boolean;
     /**
      * Automatically join M:1 and 1:1 relations when filters are defined on them.
      * Important for implementing soft deletes via filters.
      * @default true
      */
-    autoJoinRefsForFilters?: boolean;
+    autoJoinRefsForFilters: boolean;
     /**
      * Apply filters to relations in queries.
      * @default true
      */
-    filtersOnRelations?: boolean;
+    filtersOnRelations: boolean;
     /**
      * Enable propagation of changes on entity prototypes.
      * @default true
      */
-    propagationOnPrototype?: boolean;
+    propagationOnPrototype: boolean;
     /**
      * Mark all relations as populated after flush for new entities.
      * This aligns serialized output of loaded entities and just-inserted ones.
      * @default true
      */
-    populateAfterFlush?: boolean;
+    populateAfterFlush: boolean;
     /**
      * Serialization options for `toJSON()` and `serialize()` methods.
      */
-    serialization?: {
+    serialization: {
         /**
          * Include primary keys in serialized output.
          * @default true
@@ -604,42 +493,42 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Default options for entity assignment via `em.assign()`.
      * @see https://mikro-orm.io/docs/entity-helper
      */
-    assign?: AssignOptions<boolean>;
+    assign: AssignOptions<boolean>;
     /**
      * Automatically call `em.persist()` on entities created via `em.create()`.
      * @default true
      */
-    persistOnCreate?: boolean;
+    persistOnCreate: boolean;
     /**
      * When upsert creates a new entity, mark it as managed in the identity map.
      * @default true
      */
-    upsertManaged?: boolean;
+    upsertManaged: boolean;
     /**
      * Force use of entity constructors when creating entity instances.
      * Required when using native private properties inside entities.
      * Can be `true` for all entities or an array of specific entity classes/names.
      * @default false
      */
-    forceEntityConstructor?: boolean | (Constructor<AnyEntity> | string)[];
+    forceEntityConstructor: boolean | (Constructor<AnyEntity> | string)[];
     /**
      * Convert `null` values from database to `undefined` when hydrating entities.
      * @default false
      */
-    forceUndefined?: boolean;
+    forceUndefined: boolean;
     /**
      * Property `onCreate` hooks are normally executed during `flush` operation.
      * With this option, they will be processed early inside `em.create()` method.
      * @default true
      */
-    processOnCreateHooksEarly?: boolean;
+    processOnCreateHooksEarly: boolean;
     /**
      * Force `Date` values to be stored in UTC for datetime columns without timezone.
      * Works for MySQL (`datetime` type), PostgreSQL (`timestamp` type), and MSSQL (`datetime`/`datetime2` types).
      * SQLite does this by default.
      * @default true
      */
-    forceUtcTimezone?: boolean;
+    forceUtcTimezone: boolean;
     /**
      * Timezone to use for date operations.
      * @example '+02:00'
@@ -650,13 +539,13 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * When `true`, will create the database if it doesn't exist.
      * @default true
      */
-    ensureDatabase?: boolean | EnsureDatabaseOptions;
+    ensureDatabase: boolean | EnsureDatabaseOptions;
     /**
      * Ensure database indexes exist on startup. This option works only with the MongoDB driver.
      * When enabled, indexes will be created based on entity metadata.
      * @default false
      */
-    ensureIndexes?: boolean;
+    ensureIndexes: boolean;
     /**
      * Use batch insert queries for better performance.
      * @default true
@@ -671,12 +560,12 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Number of entities to process in each batch for batch inserts/updates.
      * @default 300
      */
-    batchSize?: number;
+    batchSize: number;
     /**
      * Custom hydrator class for assigning database values to entities.
      * @default ObjectHydrator
      */
-    hydrator?: HydratorConstructor;
+    hydrator: HydratorConstructor;
     /**
      * Pre-generated compiled functions for hydration and comparison.
      * Use the `compile` CLI command to create these functions.
@@ -690,7 +579,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * - `'balanced'`: Decides based on relation type and context.
      * @default 'balanced'
      */
-    loadStrategy?: LoadStrategy | `${LoadStrategy}`;
+    loadStrategy: LoadStrategy | `${LoadStrategy}`;
     /**
      * Enable dataloader for batching reference loading.
      * - `true` or `DataloaderType.ALL`: Enable for all relation types
@@ -699,14 +588,14 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * - `DataloaderType.COLLECTION`: Enable only for collections
      * @default DataloaderType.NONE
      */
-    dataloader?: DataloaderType | boolean;
+    dataloader: DataloaderType | boolean;
     /**
      * Determines how where conditions are applied during population.
      * - `'all'`: Populate all matching relations (default in v5+)
      * - `'infer'`: Infer conditions from the original query (v4 behavior)
      * @default 'all'
      */
-    populateWhere?: PopulateHint | `${PopulateHint}`;
+    populateWhere: PopulateHint | `${PopulateHint}`;
     /**
      * Default flush mode for the entity manager.
      * - `'commit'`: Flush only on explicit commit
@@ -714,7 +603,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * - `'always'`: Always flush before queries
      * @default 'auto'
      */
-    flushMode?: FlushMode | `${FlushMode}`;
+    flushMode: FlushMode | `${FlushMode}`;
     /**
      * Custom base repository class for all entities.
      * Entity-specific repositories can still be defined and will take precedence.
@@ -735,25 +624,25 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Validate that required properties are set on new entities before insert.
      * @default true
      */
-    validateRequired?: boolean;
+    validateRequired: boolean;
     /**
      * Callback to get the current request context's EntityManager.
      * Used for automatic context propagation in web frameworks.
      * @default RequestContext.getEntityManager
      */
-    context?: (name: string) => EntityManager | undefined;
+    context: (name: string) => EntityManager | undefined;
     /**
      * Name of the context for multi-ORM setups.
      * @default 'default'
      */
-    contextName?: string;
+    contextName: string;
     /**
      * Allow using the global EntityManager without a request context.
      * Not recommended for production - each request should have its own context.
      * Can also be set via `MIKRO_ORM_ALLOW_GLOBAL_CONTEXT` environment variable.
      * @default false
      */
-    allowGlobalContext?: boolean;
+    allowGlobalContext: boolean;
     /**
      * When enabled, environment variables take precedence over explicitly provided config options.
      * By default, explicit options win over env vars.
@@ -771,12 +660,12 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Custom logger function for ORM output.
      * @default console.log
      */
-    logger?: (message: string) => void;
+    logger: (message: string) => void;
     /**
      * Enable colored output in logs.
      * @default true
      */
-    colors?: boolean;
+    colors: boolean;
     /**
      * Factory function to create a custom logger instance.
      * @default DefaultLogger.create
@@ -788,7 +677,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @param where - Query conditions
      * @returns Error instance to throw
      */
-    findOneOrFailHandler?: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
+    findOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
     /**
      * Custom error handler for `em.findExactlyOneOrFail()` when entity count is not exactly one.
      * Used when strict mode is enabled.
@@ -796,7 +685,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @param where - Query conditions
      * @returns Error instance to throw
      */
-    findExactlyOneOrFailHandler?: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
+    findExactlyOneOrFailHandler: (entityName: string, where: Dictionary | IPrimaryKey) => Error;
     /**
      * Enable debug logging.
      * Can be `true` for all namespaces or an array of specific namespaces.
@@ -804,19 +693,19 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default false
      * @see https://mikro-orm.io/docs/logging
      */
-    debug?: boolean | LoggerNamespace[];
+    debug: boolean | LoggerNamespace[];
     /**
      * Ignore deprecation warnings.
      * Can be `true` to ignore all or an array of specific deprecation labels.
      * @default false
      * @see https://mikro-orm.io/docs/logging#deprecation-warnings
      */
-    ignoreDeprecations?: boolean | string[];
+    ignoreDeprecations: boolean | string[];
     /**
      * Syntax highlighter for SQL queries in logs.
      * @default NullHighlighter
      */
-    highlighter?: Highlighter;
+    highlighter: Highlighter;
     /**
      * Force the ORM to use TypeScript options regardless of detection.
      * Uses `entitiesTs` for discovery and `pathTs` for migrations/seeders.
@@ -828,16 +717,16 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Base directory for resolving relative paths.
      * @default process.cwd()
      */
-    baseDir?: string;
+    baseDir: string;
     /**
      * Migration configuration options.
      * @see https://mikro-orm.io/docs/migrations
      */
-    migrations?: MigrationsOptions;
+    migrations: MigrationsOptions;
     /**
      * Schema generator configuration options.
      */
-    schemaGenerator?: {
+    schemaGenerator: {
         /**
          * Try to disable foreign key checks during schema operations.
          * @default false
@@ -891,7 +780,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
     /**
      * Embeddable entity configuration options.
      */
-    embeddables?: {
+    embeddables: {
         /**
          * Mode for generating column prefixes for embedded properties.
          * @default 'relative'
@@ -902,12 +791,12 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Entity generator (code generation) configuration options.
      * @see https://mikro-orm.io/docs/entity-generator
      */
-    entityGenerator?: GenerateOptions;
+    entityGenerator: GenerateOptions;
     /**
      * Metadata cache configuration for improved startup performance.
      * @see https://mikro-orm.io/docs/metadata-cache
      */
-    metadataCache?: {
+    metadataCache: {
         /**
          * Enable metadata caching.
          * Defaults based on the metadata provider's `useCache()` method.
@@ -938,7 +827,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
     /**
      * Result cache configuration for query result caching.
      */
-    resultCache?: {
+    resultCache: {
         /**
          * Default cache expiration time in milliseconds.
          * @default 1000
@@ -968,7 +857,7 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * @default ReflectMetadataProvider
      * @see https://mikro-orm.io/docs/metadata-providers
      */
-    metadataProvider?: {
+    metadataProvider: {
         new (config: Configuration): MetadataProvider;
         useCache?: MetadataProvider['useCache'];
     };
@@ -976,22 +865,15 @@ export interface Options<Driver extends IDatabaseDriver = IDatabaseDriver, EM ex
      * Seeder configuration options.
      * @see https://mikro-orm.io/docs/seeding
      */
-    seeder?: SeederOptions;
+    seeder: SeederOptions;
     /**
      * Prefer read replicas for read operations when available.
      * @default true
      */
-    preferReadReplicas?: boolean;
+    preferReadReplicas: boolean;
     /**
      * Custom dynamic import provider for loading modules.
      * @default (id) => import(id)
      */
-    dynamicImportProvider?: (id: string) => Promise<unknown>;
+    dynamicImportProvider: (id: string) => Promise<unknown>;
 }
-type MarkRequired<T, D> = {
-    [K in keyof T as Extract<K, keyof D>]-?: T[K];
-} & {
-    [K in keyof T as Exclude<K, keyof D>]?: T[K];
-};
-export type RequiredOptions<D extends IDatabaseDriver = IDatabaseDriver, EM extends EntityManager<D> = EntityManager<D>, Entities extends (string | EntityClass<AnyEntity> | EntitySchema)[] = (string | EntityClass<AnyEntity> | EntitySchema)[]> = MarkRequired<Options<D, EM, Entities>, typeof DEFAULTS>;
-export {};

package/utils/Cursor.d.ts

@@ -1,4 +1,4 @@
-import type { EntityMetadata, FilterObject, Loaded } from '../typings.js';
+import type { EntityKey, EntityMetadata, FilterObject, Loaded } from '../typings.js';
 import type { FindByCursorOptions, OrderDefinition } from '../drivers/IDatabaseDriver.js';
 import { type QueryOrder } from '../enums.js';
 /**
@@ -69,5 +69,5 @@ export declare class Cursor<Entity extends object, Hint extends string = never,
     static for<Entity extends object>(meta: EntityMetadata<Entity>, entity: FilterObject<Entity>, orderBy: OrderDefinition<Entity>): string;
     static encode(value: unknown[]): string;
     static decode(value: string): unknown[];
-    static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [never, QueryOrder][];
+    static getDefinition<Entity extends object>(meta: EntityMetadata<Entity>, orderBy: OrderDefinition<Entity>): [EntityKey, QueryOrder][];
 }

package/utils/EntityComparator.d.ts

@@ -1,4 +1,4 @@
-import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage } from '../typings.js';
+import type { EntityData, EntityDictionary, EntityMetadata, EntityName, EntityProperty, IMetadataStorage, Primary } from '../typings.js';
 import type { Platform } from '../platforms/Platform.js';
 import type { Configuration } from './Configuration.js';
 type Comparator<T> = (a: T, b: T, options?: {
@@ -6,6 +6,8 @@ type Comparator<T> = (a: T, b: T, options?: {
 }) => EntityData<T>;
 type ResultMapper<T> = (result: EntityData<T>) => EntityData<T> | null;
 type SnapshotGenerator<T> = (entity: T) => EntityData<T>;
+type PkGetter<T> = (entity: T) => Primary<T>;
+type PkSerializer<T> = (entity: T) => string;
 type CompositeKeyPart = string | CompositeKeyPart[];
 export declare class EntityComparator {
     #private;
@@ -29,15 +31,15 @@ export declare class EntityComparator {
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkGetter<T>(meta: EntityMetadata<T>): any;
+    getPkGetter<T>(meta: EntityMetadata<T>): PkGetter<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkGetterConverted<T>(meta: EntityMetadata<T>): any;
+    getPkGetterConverted<T>(meta: EntityMetadata<T>): PkGetter<T>;
     /**
      * @internal Highly performance-sensitive method.
      */
-    getPkSerializer<T>(meta: EntityMetadata<T>): any;
+    getPkSerializer<T>(meta: EntityMetadata<T>): PkSerializer<T>;
     /**
      * @internal Highly performance-sensitive method.
      */

package/utils/RawQueryFragment.d.ts

@@ -19,7 +19,7 @@ export declare class RawQueryFragment<Alias extends string = string> {
     static isKnownFragmentSymbol(key: unknown): key is RawQueryFragmentSymbol;
     static hasObjectFragments(object: unknown): boolean;
     static isKnownFragment(key: unknown): key is RawQueryFragment | symbol;
-    static getKnownFragment(key: unknown): RawQueryFragment<any> | undefined;
+    static getKnownFragment(key: unknown): RawQueryFragment | undefined;
 }
 export { RawQueryFragment as Raw };
 export declare function isRaw(value: unknown): value is RawQueryFragment;
@@ -102,8 +102,8 @@ export declare function raw<R = RawQueryFragment & symbol, T extends object = an
  */
 export declare function sql<R = RawQueryFragment & symbol>(sql: readonly string[], ...values: unknown[]): R;
 export declare namespace sql {
-    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment<string> & symbol;
-    var now: (length?: number) => RawQueryFragment<string> & symbol;
+    var ref: <T extends object = any>(...keys: string[]) => RawQueryFragment & symbol;
+    var now: (length?: number) => RawQueryFragment & symbol;
     var lower: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
     var upper: <R = RawQueryFragment<string> & symbol, T extends object = any>(key: string | ((alias: string) => string)) => R;
 }
@@ -123,4 +123,4 @@ export declare function createSqlFunction<R = RawQueryFragment & symbol, T exten
  */
 export declare function quote(expParts: readonly string[], ...values: (string | {
     toString(): string;
-})[]): RawQueryFragment<string> & symbol;
+})[]): RawQueryFragment & symbol;

package/utils/Utils.js

@@ -123,7 +123,7 @@ export function parseJsonSafe(value) {
 }
 export class Utils {
     static PK_SEPARATOR = '~~~';
-    static #ORM_VERSION = '7.0.0-dev.323';
+    static #ORM_VERSION = '7.0.0-dev.325';
     /**
      * Checks if the argument is instance of `Object`. Returns false for arrays.
      */

package/utils/fs-utils.d.ts

@@ -1,5 +1,5 @@
 import { type Dictionary } from '../typings.js';
-export declare const fs: {
+export interface FsUtils {
     init(): Promise<void>;
     pathExists(path: string): boolean;
     ensureDir(path: string): void;
@@ -10,25 +10,11 @@ export declare const fs: {
     getORMPackages(): Set<string>;
     getORMPackageVersion(name: string): string | undefined;
     checkPackageVersion(): void;
-    /**
-     * Resolves and normalizes a series of path parts relative to each preceding part.
-     * If any part is a `file:` URL, it is converted to a local path. If any part is an
-     * absolute path, it replaces preceding paths (similar to `path.resolve` in NodeJS).
-     * Trailing directory separators are removed, and all directory separators are converted
-     * to POSIX-style separators (`/`).
-     */
     normalizePath(...parts: string[]): string;
-    /**
-     * Determines the relative path between two paths. If either path is a `file:` URL,
-     * it is converted to a local path.
-     */
     relativePath(path: string, relativeTo: string): string;
-    /**
-     * Computes the absolute path to for the given path relative to the provided base directory.
-     * If either `path` or `baseDir` are `file:` URLs, they are converted to local paths.
-     */
     absolutePath(path: string, baseDir?: string): string;
     writeFile(path: string, data: string, options?: Record<string, any>): Promise<void>;
     dynamicImport<T = any>(id: string): Promise<T>;
-};
+}
+export declare const fs: FsUtils;
 export * from '../cache/FileCacheAdapter.js';