@mikro-orm/core 7.0.4 → 7.0.5-dev.0

package/metadata/MetadataProvider.d.ts

@@ -3,31 +3,28 @@ import type { Logger } from '../logging/Logger.js';
 import type { SyncCacheAdapter } from '../cache/CacheAdapter.js';
 import type { Platform } from '../platforms/Platform.js';
 export interface IConfiguration {
-  get(key: string, defaultValue?: any): any;
-  getLogger(): Logger;
-  getMetadataCacheAdapter(): SyncCacheAdapter;
-  getPlatform(): Platform;
+    get(key: string, defaultValue?: any): any;
+    getLogger(): Logger;
+    getMetadataCacheAdapter(): SyncCacheAdapter;
+    getPlatform(): Platform;
 }
 /** Base metadata provider that resolves entity type information and manages metadata caching. */
 export declare class MetadataProvider {
-  protected readonly config: IConfiguration;
-  constructor(config: IConfiguration);
-  /** Resolves entity references and type information for all properties in the given metadata. */
-  loadEntityMetadata(meta: EntityMetadata): void;
-  /** Merges cached metadata into the given entity metadata, preserving function expressions. */
-  loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
-  /** Whether this provider class uses metadata caching by default. */
-  static useCache(): boolean;
-  /** Whether metadata caching is enabled for this instance. */
-  useCache(): boolean;
-  saveToCache(meta: EntityMetadata): void;
-  /** Attempts to load metadata from cache, returning undefined if not available. */
-  getCachedMetadata<T>(
-    meta: Pick<EntityMetadata<T>, 'className' | 'path' | 'root'>,
-    root: EntityMetadata<T>,
-  ): EntityMetadata<T> | undefined;
-  /** Combines individual metadata cache entries into a single file. */
-  combineCache(): void;
-  /** Returns the cache key for the given entity metadata. */
-  getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
+    protected readonly config: IConfiguration;
+    constructor(config: IConfiguration);
+    /** Resolves entity references and type information for all properties in the given metadata. */
+    loadEntityMetadata(meta: EntityMetadata): void;
+    /** Merges cached metadata into the given entity metadata, preserving function expressions. */
+    loadFromCache(meta: EntityMetadata, cache: EntityMetadata): void;
+    /** Whether this provider class uses metadata caching by default. */
+    static useCache(): boolean;
+    /** Whether metadata caching is enabled for this instance. */
+    useCache(): boolean;
+    saveToCache(meta: EntityMetadata): void;
+    /** Attempts to load metadata from cache, returning undefined if not available. */
+    getCachedMetadata<T>(meta: Pick<EntityMetadata<T>, 'className' | 'path' | 'root'>, root: EntityMetadata<T>): EntityMetadata<T> | undefined;
+    /** Combines individual metadata cache entries into a single file. */
+    combineCache(): void;
+    /** Returns the cache key for the given entity metadata. */
+    getCacheKey(meta: Pick<EntityMetadata, 'className' | 'path'>): string;
 }

package/metadata/MetadataProvider.js

@@ -2,94 +2,96 @@ import { Utils } from '../utils/Utils.js';
 import { EntitySchema } from './EntitySchema.js';
 /** Base metadata provider that resolves entity type information and manages metadata caching. */
 export class MetadataProvider {
-  config;
-  constructor(config) {
-    this.config = config;
-  }
-  /** Resolves entity references and type information for all properties in the given metadata. */
-  loadEntityMetadata(meta) {
-    for (const prop of meta.props) {
-      /* v8 ignore next */
-      if (typeof prop.entity === 'string') {
-        prop.type = prop.entity;
-      } else if (prop.entity) {
-        const tmp = prop.entity();
-        prop.type = Array.isArray(tmp)
-          ? tmp
-              .map(t => Utils.className(t))
-              .sort()
-              .join(' | ')
-          : Utils.className(tmp);
-        prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
-      } else if (!prop.type && !((prop.enum || prop.array) && (prop.items?.length ?? 0) > 0)) {
-        throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);
-      }
+    config;
+    constructor(config) {
+        this.config = config;
     }
-  }
-  /** Merges cached metadata into the given entity metadata, preserving function expressions. */
-  loadFromCache(meta, cache) {
-    Object.values(cache.properties).forEach(prop => {
-      const metaProp = meta.properties[prop.name];
-      /* v8 ignore next */
-      if (metaProp?.enum && Array.isArray(metaProp.items)) {
-        delete prop.items;
-      }
-    });
-    // Preserve function expressions from indexes/uniques — they can't survive JSON cache serialization
-    const expressionMap = new Map();
-    for (const arr of [meta.indexes, meta.uniques]) {
-      for (const idx of arr ?? []) {
-        if (typeof idx.expression === 'function' && idx.name) {
-          expressionMap.set(idx.name, idx.expression);
+    /** Resolves entity references and type information for all properties in the given metadata. */
+    loadEntityMetadata(meta) {
+        for (const prop of meta.props) {
+            /* v8 ignore next */
+            if (typeof prop.entity === 'string') {
+                prop.type = prop.entity;
+            }
+            else if (prop.entity) {
+                const tmp = prop.entity();
+                prop.type = Array.isArray(tmp)
+                    ? tmp
+                        .map(t => Utils.className(t))
+                        .sort()
+                        .join(' | ')
+                    : Utils.className(tmp);
+                prop.target = EntitySchema.is(tmp) ? tmp.meta.class : tmp;
+            }
+            else if (!prop.type && !((prop.enum || prop.array) && (prop.items?.length ?? 0) > 0)) {
+                throw new Error(`Please provide either 'type' or 'entity' attribute in ${meta.className}.${prop.name}.`);
+            }
         }
-      }
     }
-    Utils.mergeConfig(meta, cache);
-    // Restore function expressions that were lost during JSON serialization
-    if (expressionMap.size > 0) {
-      for (const arr of [meta.indexes, meta.uniques]) {
-        for (const idx of arr ?? []) {
-          const fn = idx.name && expressionMap.get(idx.name);
-          if (fn && typeof idx.expression !== 'function') {
-            idx.expression = fn;
-          }
+    /** Merges cached metadata into the given entity metadata, preserving function expressions. */
+    loadFromCache(meta, cache) {
+        Object.values(cache.properties).forEach(prop => {
+            const metaProp = meta.properties[prop.name];
+            /* v8 ignore next */
+            if (metaProp?.enum && Array.isArray(metaProp.items)) {
+                delete prop.items;
+            }
+        });
+        // Preserve function expressions from indexes/uniques — they can't survive JSON cache serialization
+        const expressionMap = new Map();
+        for (const arr of [meta.indexes, meta.uniques]) {
+            for (const idx of arr ?? []) {
+                if (typeof idx.expression === 'function' && idx.name) {
+                    expressionMap.set(idx.name, idx.expression);
+                }
+            }
         }
-      }
+        Utils.mergeConfig(meta, cache);
+        // Restore function expressions that were lost during JSON serialization
+        if (expressionMap.size > 0) {
+            for (const arr of [meta.indexes, meta.uniques]) {
+                for (const idx of arr ?? []) {
+                    const fn = idx.name && expressionMap.get(idx.name);
+                    if (fn && typeof idx.expression !== 'function') {
+                        idx.expression = fn;
+                    }
+                }
+            }
+        }
+    }
+    /** Whether this provider class uses metadata caching by default. */
+    static useCache() {
+        return false;
     }
-  }
-  /** Whether this provider class uses metadata caching by default. */
-  static useCache() {
-    return false;
-  }
-  /** Whether metadata caching is enabled for this instance. */
-  useCache() {
-    return this.config.get('metadataCache').enabled ?? MetadataProvider.useCache();
-  }
-  saveToCache(meta) {
-    //
-  }
-  /** Attempts to load metadata from cache, returning undefined if not available. */
-  getCachedMetadata(meta, root) {
-    if (!this.useCache()) {
-      return undefined;
+    /** Whether metadata caching is enabled for this instance. */
+    useCache() {
+        return this.config.get('metadataCache').enabled ?? MetadataProvider.useCache();
     }
-    const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
-    if (cache) {
-      this.loadFromCache(meta, cache);
-      meta.root = root;
+    saveToCache(meta) {
+        //
+    }
+    /** Attempts to load metadata from cache, returning undefined if not available. */
+    getCachedMetadata(meta, root) {
+        if (!this.useCache()) {
+            return undefined;
+        }
+        const cache = meta.path && this.config.getMetadataCacheAdapter().get(this.getCacheKey(meta));
+        if (cache) {
+            this.loadFromCache(meta, cache);
+            meta.root = root;
+        }
+        return cache;
+    }
+    /** Combines individual metadata cache entries into a single file. */
+    combineCache() {
+        const path = this.config.getMetadataCacheAdapter().combine?.();
+        // override the path in the options, so we can log it from the CLI in `cache:generate` command
+        if (path) {
+            this.config.get('metadataCache').combined = path;
+        }
     }
-    return cache;
-  }
-  /** Combines individual metadata cache entries into a single file. */
-  combineCache() {
-    const path = this.config.getMetadataCacheAdapter().combine?.();
-    // override the path in the options, so we can log it from the CLI in `cache:generate` command
-    if (path) {
-      this.config.get('metadataCache').combined = path;
+    /** Returns the cache key for the given entity metadata. */
+    getCacheKey(meta) {
+        return meta.className;
     }
-  }
-  /** Returns the cache key for the given entity metadata. */
-  getCacheKey(meta) {
-    return meta.className;
-  }
 }

package/metadata/MetadataStorage.d.ts

@@ -2,42 +2,36 @@ import { type Dictionary, EntityMetadata, type EntityName } from '../typings.js'
 import type { EntityManager } from '../EntityManager.js';
 /** Registry that stores and provides access to entity metadata by class, name, or id. */
 export declare class MetadataStorage {
-  #private;
-  static readonly PATH_SYMBOL: unique symbol;
-  constructor(metadata?: Dictionary<EntityMetadata>);
-  /** Returns the global metadata dictionary, or a specific entry by entity name and path. */
-  static getMetadata(): Dictionary<EntityMetadata>;
-  static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
-  /** Checks whether an entity with the given class name exists in the global metadata. */
-  static isKnownEntity(name: string): boolean;
-  /** Clears all entries from the global metadata registry. */
-  static clear(): void;
-  /** Returns the map of all registered entity metadata. */
-  getAll(): Map<EntityName, EntityMetadata>;
-  /** Returns metadata for the given entity, optionally initializing it if not found. */
-  get<T = any>(entityName: EntityName<T>, init?: boolean): EntityMetadata<T>;
-  /** Finds metadata for the given entity, returning undefined if not registered. */
-  find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
-  /** Checks whether metadata exists for the given entity. */
-  has<T>(entityName: EntityName<T>): boolean;
-  /** Registers metadata for the given entity. */
-  set<T>(entityName: EntityName<T>, meta: EntityMetadata): EntityMetadata;
-  /** Removes metadata for the given entity from all internal maps. */
-  reset<T>(entityName: EntityName<T>): void;
-  /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */
-  decorate(em: EntityManager): void;
-  [Symbol.iterator](): IterableIterator<EntityMetadata>;
-  /** Returns metadata by its internal numeric id. */
-  getById<T>(id: number): EntityMetadata<T>;
-  /** Returns metadata by class name, optionally throwing if not found. */
-  getByClassName<T = any, V extends boolean = true>(
-    className: string,
-    validate?: V,
-  ): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
-  /** Returns metadata by unique name, optionally throwing if not found. */
-  getByUniqueName<T = any, V extends boolean = true>(
-    uniqueName: string,
-    validate?: V,
-  ): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
-  private validate;
+    #private;
+    static readonly PATH_SYMBOL: unique symbol;
+    constructor(metadata?: Dictionary<EntityMetadata>);
+    /** Returns the global metadata dictionary, or a specific entry by entity name and path. */
+    static getMetadata(): Dictionary<EntityMetadata>;
+    static getMetadata<T = any>(entity: string, path: string): EntityMetadata<T>;
+    /** Checks whether an entity with the given class name exists in the global metadata. */
+    static isKnownEntity(name: string): boolean;
+    /** Clears all entries from the global metadata registry. */
+    static clear(): void;
+    /** Returns the map of all registered entity metadata. */
+    getAll(): Map<EntityName, EntityMetadata>;
+    /** Returns metadata for the given entity, optionally initializing it if not found. */
+    get<T = any>(entityName: EntityName<T>, init?: boolean): EntityMetadata<T>;
+    /** Finds metadata for the given entity, returning undefined if not registered. */
+    find<T = any>(entityName: EntityName<T>): EntityMetadata<T> | undefined;
+    /** Checks whether metadata exists for the given entity. */
+    has<T>(entityName: EntityName<T>): boolean;
+    /** Registers metadata for the given entity. */
+    set<T>(entityName: EntityName<T>, meta: EntityMetadata): EntityMetadata;
+    /** Removes metadata for the given entity from all internal maps. */
+    reset<T>(entityName: EntityName<T>): void;
+    /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */
+    decorate(em: EntityManager): void;
+    [Symbol.iterator](): IterableIterator<EntityMetadata>;
+    /** Returns metadata by its internal numeric id. */
+    getById<T>(id: number): EntityMetadata<T>;
+    /** Returns metadata by class name, optionally throwing if not found. */
+    getByClassName<T = any, V extends boolean = true>(className: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    /** Returns metadata by unique name, optionally throwing if not found. */
+    getByUniqueName<T = any, V extends boolean = true>(uniqueName: string, validate?: V): V extends true ? EntityMetadata<T> : EntityMetadata<T> | undefined;
+    private validate;
 }

package/metadata/MetadataStorage.js

@@ -4,125 +4,125 @@ import { MetadataError } from '../errors.js';
 import { EntityHelper } from '../entity/EntityHelper.js';
 import { EntitySchema } from './EntitySchema.js';
 function getGlobalStorage(namespace) {
-  const key = `mikro-orm-${namespace}`;
-  globalThis[key] = globalThis[key] || {};
-  return globalThis[key];
+    const key = `mikro-orm-${namespace}`;
+    globalThis[key] = globalThis[key] || {};
+    return globalThis[key];
 }
 /** Registry that stores and provides access to entity metadata by class, name, or id. */
 export class MetadataStorage {
-  static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
-  static #metadata = getGlobalStorage('metadata');
-  #metadataMap = new Map();
-  #idMap;
-  #classNameMap;
-  #uniqueNameMap;
-  constructor(metadata = {}) {
-    this.#idMap = {};
-    this.#uniqueNameMap = {};
-    this.#classNameMap = Utils.copy(metadata, false);
-    for (const meta of Object.values(this.#classNameMap)) {
-      this.#idMap[meta._id] = meta;
-      this.#uniqueNameMap[meta.uniqueName] = meta;
-      this.#metadataMap.set(meta.class, meta);
-    }
-  }
-  static getMetadata(entity, path) {
-    const key = entity && path ? entity + '-' + Utils.hash(path) : null;
-    if (key && !MetadataStorage.#metadata[key]) {
-      MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
-    }
-    if (key) {
-      return MetadataStorage.#metadata[key];
-    }
-    return MetadataStorage.#metadata;
-  }
-  /** Checks whether an entity with the given class name exists in the global metadata. */
-  static isKnownEntity(name) {
-    return !!Object.values(this.#metadata).find(meta => meta.className === name);
-  }
-  /** Clears all entries from the global metadata registry. */
-  static clear() {
-    Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
-  }
-  /** Returns the map of all registered entity metadata. */
-  getAll() {
-    return this.#metadataMap;
-  }
-  /** Returns metadata for the given entity, optionally initializing it if not found. */
-  get(entityName, init = false) {
-    const exists = this.find(entityName);
-    if (exists) {
-      return exists;
-    }
-    const className = Utils.className(entityName);
-    if (!init) {
-      throw MetadataError.missingMetadata(className);
-    }
-    const meta = new EntityMetadata({ class: entityName, name: className });
-    this.set(entityName, meta);
-    return meta;
-  }
-  /** Finds metadata for the given entity, returning undefined if not registered. */
-  find(entityName) {
-    if (!entityName) {
-      return;
-    }
-    const meta = this.#metadataMap.get(entityName);
-    if (meta) {
-      return meta;
-    }
-    if (EntitySchema.is(entityName)) {
-      return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
-    }
-    return this.#classNameMap[Utils.className(entityName)];
-  }
-  /** Checks whether metadata exists for the given entity. */
-  has(entityName) {
-    return this.#metadataMap.has(entityName);
-  }
-  /** Registers metadata for the given entity. */
-  set(entityName, meta) {
-    this.#metadataMap.set(entityName, meta);
-    this.#idMap[meta._id] = meta;
-    this.#uniqueNameMap[meta.uniqueName] = meta;
-    this.#classNameMap[Utils.className(entityName)] = meta;
-    return meta;
-  }
-  /** Removes metadata for the given entity from all internal maps. */
-  reset(entityName) {
-    const meta = this.find(entityName);
-    if (meta) {
-      this.#metadataMap.delete(meta.class);
-      delete this.#idMap[meta._id];
-      delete this.#uniqueNameMap[meta.uniqueName];
-      delete this.#classNameMap[meta.className];
-    }
-  }
-  /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */
-  decorate(em) {
-    [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
-  }
-  *[Symbol.iterator]() {
-    for (const meta of this.#metadataMap.values()) {
-      yield meta;
-    }
-  }
-  /** Returns metadata by its internal numeric id. */
-  getById(id) {
-    return this.#idMap[id];
-  }
-  /** Returns metadata by class name, optionally throwing if not found. */
-  getByClassName(className, validate = true) {
-    return this.validate(this.#classNameMap[className], className, validate);
-  }
-  /** Returns metadata by unique name, optionally throwing if not found. */
-  getByUniqueName(uniqueName, validate = true) {
-    return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
-  }
-  validate(meta, id, validate) {
-    if (!meta && validate) {
-      throw MetadataError.missingMetadata(id);
-    }
-    return meta;
-  }
+    static PATH_SYMBOL = Symbol.for('@mikro-orm/core/MetadataStorage.PATH_SYMBOL');
+    static #metadata = getGlobalStorage('metadata');
+    #metadataMap = new Map();
+    #idMap;
+    #classNameMap;
+    #uniqueNameMap;
+    constructor(metadata = {}) {
+        this.#idMap = {};
+        this.#uniqueNameMap = {};
+        this.#classNameMap = Utils.copy(metadata, false);
+        for (const meta of Object.values(this.#classNameMap)) {
+            this.#idMap[meta._id] = meta;
+            this.#uniqueNameMap[meta.uniqueName] = meta;
+            this.#metadataMap.set(meta.class, meta);
+        }
+    }
+    static getMetadata(entity, path) {
+        const key = entity && path ? entity + '-' + Utils.hash(path) : null;
+        if (key && !MetadataStorage.#metadata[key]) {
+            MetadataStorage.#metadata[key] = new EntityMetadata({ className: entity, path });
+        }
+        if (key) {
+            return MetadataStorage.#metadata[key];
+        }
+        return MetadataStorage.#metadata;
+    }
+    /** Checks whether an entity with the given class name exists in the global metadata. */
+    static isKnownEntity(name) {
+        return !!Object.values(this.#metadata).find(meta => meta.className === name);
+    }
+    /** Clears all entries from the global metadata registry. */
+    static clear() {
+        Object.keys(this.#metadata).forEach(k => delete this.#metadata[k]);
+    }
+    /** Returns the map of all registered entity metadata. */
+    getAll() {
+        return this.#metadataMap;
+    }
+    /** Returns metadata for the given entity, optionally initializing it if not found. */
+    get(entityName, init = false) {
+        const exists = this.find(entityName);
+        if (exists) {
+            return exists;
+        }
+        const className = Utils.className(entityName);
+        if (!init) {
+            throw MetadataError.missingMetadata(className);
+        }
+        const meta = new EntityMetadata({ class: entityName, name: className });
+        this.set(entityName, meta);
+        return meta;
+    }
+    /** Finds metadata for the given entity, returning undefined if not registered. */
+    find(entityName) {
+        if (!entityName) {
+            return;
+        }
+        const meta = this.#metadataMap.get(entityName);
+        if (meta) {
+            return meta;
+        }
+        if (EntitySchema.is(entityName)) {
+            return this.#metadataMap.get(entityName.meta.class) ?? entityName.meta;
+        }
+        return this.#classNameMap[Utils.className(entityName)];
+    }
+    /** Checks whether metadata exists for the given entity. */
+    has(entityName) {
+        return this.#metadataMap.has(entityName);
+    }
+    /** Registers metadata for the given entity. */
+    set(entityName, meta) {
+        this.#metadataMap.set(entityName, meta);
+        this.#idMap[meta._id] = meta;
+        this.#uniqueNameMap[meta.uniqueName] = meta;
+        this.#classNameMap[Utils.className(entityName)] = meta;
+        return meta;
+    }
+    /** Removes metadata for the given entity from all internal maps. */
+    reset(entityName) {
+        const meta = this.find(entityName);
+        if (meta) {
+            this.#metadataMap.delete(meta.class);
+            delete this.#idMap[meta._id];
+            delete this.#uniqueNameMap[meta.uniqueName];
+            delete this.#classNameMap[meta.className];
+        }
+    }
+    /** Decorates all entity prototypes with helper methods (e.g. init, toJSON). */
+    decorate(em) {
+        [...this.#metadataMap.values()].filter(meta => meta.prototype).forEach(meta => EntityHelper.decorate(meta, em));
+    }
+    *[Symbol.iterator]() {
+        for (const meta of this.#metadataMap.values()) {
+            yield meta;
+        }
+    }
+    /** Returns metadata by its internal numeric id. */
+    getById(id) {
+        return this.#idMap[id];
+    }
+    /** Returns metadata by class name, optionally throwing if not found. */
+    getByClassName(className, validate = true) {
+        return this.validate(this.#classNameMap[className], className, validate);
+    }
+    /** Returns metadata by unique name, optionally throwing if not found. */
+    getByUniqueName(uniqueName, validate = true) {
+        return this.validate(this.#uniqueNameMap[uniqueName], uniqueName, validate);
+    }
+    validate(meta, id, validate) {
+        if (!meta && validate) {
+            throw MetadataError.missingMetadata(id);
+        }
+        return meta;
+    }
 }

package/metadata/MetadataValidator.d.ts

@@ -5,43 +5,43 @@ import type { MetadataStorage } from './MetadataStorage.js';
  * @internal
  */
 export declare class MetadataValidator {
-  validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
-  validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
-  private validateReference;
-  private validateTargetKey;
-  /**
-   * Checks if a property has a unique constraint (either via `unique: true` or single-property `@Unique` decorator).
-   * Composite unique constraints are not sufficient for targetKey.
-   */
-  private isPropertyUnique;
-  private validatePolymorphicTargets;
-  private validateBidirectional;
-  private validateOwningSide;
-  private validateInverseSide;
-  private validateIndexes;
-  private validateDuplicateFieldNames;
-  private validateVersionField;
-  /**
-   * Validates that entity properties do not use dangerous names that could lead to
-   * prototype pollution vulnerabilities. This validation ensures that property names
-   * cannot be exploited to modify object prototypes when values are assigned during
-   * entity hydration or persistence operations.
-   *
-   * @internal
-   */
-  private validatePropertyNames;
-  /**
-   * Validates view entity configuration.
-   * View entities must have an expression.
-   */
-  private validateViewEntity;
-  /**
-   * Validates that STI and TPT are not mixed in the same inheritance hierarchy.
-   * An entity hierarchy can use either STI (discriminatorColumn) or TPT (inheritance: 'tpt'),
-   * but not both.
-   *
-   * Note: This validation runs before `initTablePerTypeInheritance` sets `inheritanceType`,
-   * so we check the raw `inheritance` option from the decorator/schema.
-   */
-  private validateInheritanceStrategies;
+    validateEntityDefinition<T>(metadata: MetadataStorage, name: EntityName<T>, options: MetadataDiscoveryOptions): void;
+    validateDiscovered(discovered: EntityMetadata[], options: MetadataDiscoveryOptions): void;
+    private validateReference;
+    private validateTargetKey;
+    /**
+     * Checks if a property has a unique constraint (either via `unique: true` or single-property `@Unique` decorator).
+     * Composite unique constraints are not sufficient for targetKey.
+     */
+    private isPropertyUnique;
+    private validatePolymorphicTargets;
+    private validateBidirectional;
+    private validateOwningSide;
+    private validateInverseSide;
+    private validateIndexes;
+    private validateDuplicateFieldNames;
+    private validateVersionField;
+    /**
+     * Validates that entity properties do not use dangerous names that could lead to
+     * prototype pollution vulnerabilities. This validation ensures that property names
+     * cannot be exploited to modify object prototypes when values are assigned during
+     * entity hydration or persistence operations.
+     *
+     * @internal
+     */
+    private validatePropertyNames;
+    /**
+     * Validates view entity configuration.
+     * View entities must have an expression.
+     */
+    private validateViewEntity;
+    /**
+     * Validates that STI and TPT are not mixed in the same inheritance hierarchy.
+     * An entity hierarchy can use either STI (discriminatorColumn) or TPT (inheritance: 'tpt'),
+     * but not both.
+     *
+     * Note: This validation runs before `initTablePerTypeInheritance` sets `inheritanceType`,
+     * so we check the raw `inheritance` option from the decorator/schema.
+     */
+    private validateInheritanceStrategies;
 }