@mikro-orm/core 7.0.0-rc.1 → 7.0.0-rc.2

package/EntityManager.d.ts

@@ -456,7 +456,7 @@ export declare class EntityManager<Driver extends IDatabaseDriver = IDatabaseDri
     /**
      * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Entity extends object, Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(entities: Entity, populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Entity extends object[] ? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Entity, Naked, Hint, Fields, Excludes>>;
+    populate<Entity extends object, Naked extends FromEntityType<UnboxArray<Entity>> = FromEntityType<UnboxArray<Entity>>, Hint extends string = never, Fields extends string = never, Excludes extends string = never>(entities: Entity, populate: readonly AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Entity extends object[] ? MergeLoaded<ArrayElement<Entity>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Entity, Naked, Hint, Fields, Excludes>>;
     /**
      * Returns new EntityManager instance with its own identity map
      */

package/EntityManager.js

@@ -1,7 +1,6 @@
 import { getOnConflictReturningFields, getWhereCondition } from './utils/upsert-utils.js';
 import { Utils } from './utils/Utils.js';
 import { Cursor } from './utils/Cursor.js';
-import { DataloaderUtils } from './utils/DataloaderUtils.js';
 import { QueryHelper } from './utils/QueryHelper.js';
 import { TransactionContext } from './utils/TransactionContext.js';
 import { isRaw, Raw } from './utils/RawQueryFragment.js';
@@ -1816,6 +1815,7 @@ export class EntityManager {
         if (em.loaders[type]) {
             return em.loaders[type];
         }
+        const { DataloaderUtils } = await import('@mikro-orm/core/dataloader');
         const DataLoader = await DataloaderUtils.getDataLoader();
         switch (type) {
             case 'ref': return (em.loaders[type] ??= new DataLoader(DataloaderUtils.getRefBatchLoadFn(em)));

package/drivers/IDatabaseDriver.d.ts

@@ -1,4 +1,4 @@
-import type { ConnectionType, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName, PopulateHintOptions, Prefixes } from '../typings.js';
+import type { ConnectionType, Constructor, EntityData, EntityMetadata, EntityProperty, FilterQuery, Primary, Dictionary, IPrimaryKey, PopulateOptions, EntityDictionary, AutoPath, ObjectQuery, FilterObject, Populate, EntityName, PopulateHintOptions, Prefixes } from '../typings.js';
 import type { Connection, QueryResult, Transaction } from '../connections/Connection.js';
 import type { FlushMode, LockMode, QueryOrderMap, QueryFlag, LoadStrategy, PopulateHint, PopulatePath } from '../enums.js';
 import type { Platform } from '../platforms/Platform.js';
@@ -7,6 +7,7 @@ import type { Collection } from '../entity/Collection.js';
 import type { EntityManager } from '../EntityManager.js';
 import type { DriverException } from '../exceptions.js';
 import type { Configuration } from '../utils/Configuration.js';
+import type { MikroORM } from '../MikroORM.js';
 import type { LoggingOptions, LogContext } from '../logging/Logger.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 export declare const EntityManagerType: unique symbol;
@@ -65,6 +66,10 @@ export interface IDatabaseDriver<C extends Connection = Connection> {
         schema?: string;
         parentSchema?: string;
     }): string | undefined;
+    /**
+     * @internal
+     */
+    getORMClass(): Constructor<MikroORM>;
 }
 export type EntityField<T, P extends string = PopulatePath.ALL> = keyof T | PopulatePath.ALL | AutoPath<T, P, `${PopulatePath.ALL}`>;
 export type OrderDefinition<T> = (QueryOrderMap<T> & {

package/entity/BaseEntity.d.ts

@@ -1,5 +1,5 @@
 import { type Ref } from './Reference.js';
-import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { AutoPath, EntityData, EntityDTO, Loaded, LoadedReference, AddEager, EntityKey, FromEntityType, IsSubset, MergeSelected, SerializeDTO } from '../typings.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
 import { type SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -8,7 +8,7 @@ import type { PopulatePath } from '../enums.js';
 export declare abstract class BaseEntity {
     isInitialized(): boolean;
     populated(populated?: boolean): void;
-    populate<Entity extends this = this, Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Entity extends this = this, Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     toReference<Entity extends this = this>(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     /**
      * Converts the entity to a plain object representation.
@@ -73,7 +73,7 @@ export declare abstract class BaseEntity {
      */
     toObject<Entity extends this = this, Ignored extends EntityKey<Entity> = never>(ignoreFields: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
     toPOJO<Entity extends this = this>(): EntityDTO<Entity>;
-    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): EntityDTO<Loaded<Naked, Hint>>;
+    serialize<Entity extends this = this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Naked, Hint, Exclude>): SerializeDTO<Naked, Hint, Exclude>;
     assign<Entity extends this, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Entity extends this = this, Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
     getSchema(): string | undefined;

package/entity/EntityFactory.js

@@ -129,7 +129,10 @@ export class EntityFactory {
             .filter(key => meta.properties[key]?.formula || [ReferenceKind.ONE_TO_MANY, ReferenceKind.MANY_TO_MANY].includes(meta.properties[key]?.kind))
             .forEach(key => diff2[key] = data[key]);
         // rehydrated with the new values, skip those changed by user
-        this.hydrate(entity, meta, diff2, options);
+        // use full hydration if the entity is already initialized, even if the caller used `initialized: false`
+        // (e.g. from createReference), otherwise scalar properties in diff2 won't be applied
+        const initialized = options.initialized || helper(entity).__initialized;
+        this.hydrate(entity, meta, diff2, initialized ? { ...options, initialized } : options);
         // we need to update the entity data only with keys that were not present before
         const nullVal = this.config.get('forceUndefined') ? undefined : null;
         Utils.keys(diff2).forEach(key => {
@@ -137,7 +140,7 @@ export class EntityFactory {
             if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && Utils.isPlainObject(data[prop.name])) {
                 diff2[key] = entity[prop.name] ? helper(entity[prop.name]).getPrimaryKey(options.convertCustomTypes) : null;
             }
-            if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
+            if (!options.convertCustomTypes && [ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE, ReferenceKind.SCALAR].includes(prop.kind) && prop.customType?.ensureComparable(meta, prop) && diff2[key] != null) {
                 const converted = prop.customType.convertToJSValue(diff2[key], this.platform, { force: true });
                 diff2[key] = prop.customType.convertToDatabaseValue(converted, this.platform, { fromQuery: true });
             }

package/entity/EntityHelper.js

@@ -1,4 +1,4 @@
-import { EagerProps, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
+import { EagerProps, EntityName, EntityRepositoryType, HiddenProps, OptionalProps, PrimaryKeyProp, } from '../typings.js';
 import { EntityTransformer } from '../serialization/EntityTransformer.js';
 import { Reference } from './Reference.js';
 import { Utils } from '../utils/Utils.js';
@@ -130,7 +130,7 @@ export class EntityHelper {
                 }
             }
             // ensure we dont have internal symbols in the POJO
-            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps].forEach(sym => delete object[sym]);
+            [OptionalProps, EntityRepositoryType, PrimaryKeyProp, EagerProps, HiddenProps, EntityName].forEach(sym => delete object[sym]);
             meta.props
                 .filter(prop => object[prop.name] === undefined)
                 .forEach(prop => delete object[prop.name]);

package/entity/EntityLoader.d.ts

@@ -1,13 +1,13 @@
-import type { AnyEntity, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
+import type { AnyEntity, AutoPath, ConnectionType, EntityName, EntityProperty, FilterQuery, PopulateOptions } from '../typings.js';
 import type { EntityManager } from '../EntityManager.js';
 import { LoadStrategy, type LockMode, type PopulateHint, PopulatePath, type QueryOrderMap } from '../enums.js';
-import type { EntityField, FilterOptions } from '../drivers/IDatabaseDriver.js';
+import type { FilterOptions } from '../drivers/IDatabaseDriver.js';
 import type { LoggingOptions } from '../logging/Logger.js';
-export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> = {
+export interface EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL, Excludes extends string = never> {
+    fields?: readonly AutoPath<Entity, Fields, `${PopulatePath.ALL}`>[];
+    exclude?: readonly AutoPath<Entity, Excludes>[];
     where?: FilterQuery<Entity>;
     populateWhere?: PopulateHint | `${PopulateHint}`;
-    fields?: readonly EntityField<Entity, Fields>[];
-    exclude?: readonly EntityField<Entity, Excludes>[];
     orderBy?: QueryOrderMap<Entity> | QueryOrderMap<Entity>[];
     refresh?: boolean;
     validate?: boolean;
@@ -20,7 +20,7 @@ export type EntityLoaderOptions<Entity, Fields extends string = PopulatePath.ALL
     schema?: string;
     connectionType?: ConnectionType;
     logging?: LoggingOptions;
-};
+}
 export declare class EntityLoader {
     private readonly em;
     private readonly metadata;

package/entity/EntityRepository.d.ts

@@ -150,7 +150,7 @@ export declare class EntityRepository<Entity extends object> {
     /**
      * Loads specified relations in batch. This will execute one query for each relation, that will populate it on all the specified entities.
      */
-    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = '*', Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
+    populate<Ent extends Entity | Entity[], Hint extends string = never, Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Fields extends string = never, Excludes extends string = never>(entities: Ent, populate: AutoPath<Naked, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Naked, Fields, Excludes>): Promise<Ent extends object[] ? MergeLoaded<ArrayElement<Ent>, Naked, Hint, Fields, Excludes>[] : MergeLoaded<Ent, Naked, Hint, Fields, Excludes>>;
     /**
      * Creates new instance of given entity and populates it with given data.
      * The entity constructor will be used unless you provide `{ managed: true }` in the `options` parameter.

package/entity/WrappedEntity.d.ts

@@ -1,6 +1,6 @@
 import type { PopulatePath } from '../enums.js';
 import type { EntityManager } from '../EntityManager.js';
-import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
+import type { Dictionary, EntityData, EntityDictionary, EntityMetadata, IHydrator, EntityKey, PopulateOptions, Primary, AutoPath, Ref, AddEager, LoadedReference, EntityDTO, Loaded, SerializeDTO, FromEntityType, IsSubset, MergeSelected } from '../typings.js';
 import { Reference } from './Reference.js';
 import { type AssignOptions } from './EntityAssigner.js';
 import type { EntityLoaderOptions } from './EntityLoader.js';
@@ -44,12 +44,12 @@ export declare class WrappedEntity<Entity extends object> {
     setSerializationContext<Hint extends string = never, Fields extends string = '*', Exclude extends string = never>(options: LoadHint<Entity, Hint, Fields, Exclude>): void;
     toReference(): Ref<Entity> & LoadedReference<Loaded<Entity, AddEager<Entity>>>;
     toObject<Ignored extends EntityKey<Entity> = never>(ignoreFields?: Ignored[]): Omit<EntityDTO<Entity>, Ignored>;
-    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): EntityDTO<Loaded<Entity, Hint>>;
+    serialize<Hint extends string = never, Exclude extends string = never>(options?: SerializeOptions<Entity, Hint, Exclude>): SerializeDTO<Entity, Hint, Exclude>;
     toPOJO(): EntityDTO<Entity>;
     toJSON(...args: any[]): EntityDictionary<Entity>;
     assign<Naked extends FromEntityType<Entity> = FromEntityType<Entity>, Convert extends boolean = false, Data extends EntityData<Naked, Convert> | Partial<EntityDTO<Naked>> = EntityData<Naked, Convert> | Partial<EntityDTO<Naked>>>(data: Data & IsSubset<EntityData<Naked>, Data>, options?: AssignOptions<Convert>): MergeSelected<Entity, Naked, keyof Data & string>;
     init<Hint extends string = never, Fields extends string = '*', Excludes extends string = never>(options?: FindOneOptions<Entity, Hint, Fields, Excludes>): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;
-    populate<Hint extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity>): Promise<Loaded<Entity, Hint>>;
+    populate<Hint extends string = never, Fields extends string = never>(populate: AutoPath<Entity, Hint, PopulatePath.ALL>[] | false, options?: EntityLoaderOptions<Entity, Fields>): Promise<Loaded<Entity, Hint>>;
     hasPrimaryKey(): boolean;
     getPrimaryKey(convertCustomTypes?: boolean): Primary<Entity> | null;
     getPrimaryKeys(convertCustomTypes?: boolean): Primary<Entity>[] | null;

package/entity/defineEntity.d.ts

@@ -16,11 +16,135 @@ type ExcludeKeys = 'entity' | 'items';
 type BuilderKeys = Exclude<UniversalPropertyKeys, ExcludeKeys> | BuilderExtraKeys;
 type IncludeKeysForProperty = Exclude<keyof PropertyOptions<any>, ExcludeKeys> | BuilderExtraKeys;
 type IncludeKeysForEnumOptions = Exclude<keyof EnumOptions<any>, ExcludeKeys> | BuilderExtraKeys;
-type IncludeKeysForEmbeddedOptions = Exclude<keyof EmbeddedOptions<any, any>, ExcludeKeys> | BuilderExtraKeys;
-type IncludeKeysForManyToOneOptions = Exclude<keyof ManyToOneOptions<any, any>, ExcludeKeys> | BuilderExtraKeys;
 type IncludeKeysForOneToManyOptions = Exclude<keyof OneToManyOptions<any, any>, ExcludeKeys> | BuilderExtraKeys;
-type IncludeKeysForOneToOneOptions = Exclude<keyof OneToOneOptions<any, any>, ExcludeKeys> | BuilderExtraKeys;
-type IncludeKeysForManyToManyOptions = Exclude<keyof ManyToManyOptions<any, any>, ExcludeKeys> | BuilderExtraKeys;
+type HasKind<Options, K extends string> = Options extends {
+    kind: infer X extends string;
+} ? X extends K ? true : false : false;
+/** Lightweight chain result type for property builders - reduces type instantiation cost by avoiding full class resolution. */
+export interface PropertyChain<Value, Options> {
+    '~type'?: {
+        value: Value;
+    };
+    '~options': Options;
+    $type<T>(): PropertyChain<T, Options>;
+    $type<Runtime, Raw, Serialized = Raw>(): PropertyChain<IType<Runtime, Raw, Serialized>, Options>;
+    nullable(): PropertyChain<Value, Omit<Options, 'nullable'> & {
+        nullable: true;
+    }>;
+    ref(): PropertyChain<Value, Omit<Options, 'ref'> & {
+        ref: true;
+    }>;
+    primary(): PropertyChain<Value, Omit<Options, 'primary'> & {
+        primary: true;
+    }>;
+    hidden(): PropertyChain<Value, Omit<Options, 'hidden'> & {
+        hidden: true;
+    }>;
+    autoincrement(): PropertyChain<Value, Omit<Options, 'autoincrement'> & {
+        autoincrement: true;
+    }>;
+    autoincrement(autoincrement: false): PropertyChain<Value, Omit<Options, 'autoincrement'> & {
+        autoincrement: false;
+    }>;
+    persist(): PropertyChain<Value, Omit<Options, 'persist'> & {
+        persist: true;
+    }>;
+    persist(persist: false): PropertyChain<Value, Omit<Options, 'persist'> & {
+        persist: false;
+    }>;
+    version(): PropertyChain<Value, Omit<Options, 'version'> & {
+        version: true;
+    }>;
+    lazy(): PropertyChain<Value, Options>;
+    name<T extends string>(name: T): PropertyChain<Value, Omit<Options, 'fieldName'> & {
+        fieldName: T;
+    }>;
+    fieldName<T extends string>(fieldName: T): PropertyChain<Value, Omit<Options, 'fieldName'> & {
+        fieldName: T;
+    }>;
+    onCreate(onCreate: (entity: any, em: EntityManager) => Value): PropertyChain<Value, Options & {
+        onCreate: (...args: any[]) => any;
+    }>;
+    default(defaultValue: string | string[] | number | number[] | boolean | null | Date | Raw): PropertyChain<Value, Omit<Options, 'default'> & {
+        default: any;
+    }>;
+    defaultRaw(defaultRaw: string): PropertyChain<Value, Options & {
+        defaultRaw: string;
+    }>;
+    formula(formula: string | FormulaCallback<any>): PropertyChain<Value, Omit<Options, 'formula'> & {
+        formula: any;
+    }>;
+    onUpdate(onUpdate: (entity: any, em: EntityManager) => Value): PropertyChain<Value, Options>;
+    fieldNames(...fieldNames: string[]): PropertyChain<Value, Options>;
+    type(type: PropertyValueType): PropertyChain<Value, Options>;
+    runtimeType(runtimeType: string): PropertyChain<Value, Options>;
+    columnType(columnType: ColumnType | AnyString): PropertyChain<Value, Options>;
+    columnTypes(...columnTypes: (ColumnType | AnyString)[]): PropertyChain<Value, Options>;
+    length(length: number): PropertyChain<Value, Options>;
+    precision(precision: number): PropertyChain<Value, Options>;
+    scale(scale: number): PropertyChain<Value, Options>;
+    returning(returning?: boolean): PropertyChain<Value, Options>;
+    unsigned(unsigned?: boolean): PropertyChain<Value, Options>;
+    hydrate(hydrate?: boolean): PropertyChain<Value, Options>;
+    concurrencyCheck(concurrencyCheck?: boolean): PropertyChain<Value, Options>;
+    generated(generated: string | GeneratedColumnCallback<any>): PropertyChain<Value, Options>;
+    check(check: string | CheckCallback<any>): PropertyChain<Value, Options>;
+    setter(setter?: boolean): PropertyChain<Value, Options>;
+    getter(getter?: boolean): PropertyChain<Value, Options>;
+    getterName(getterName: string): PropertyChain<Value, Options>;
+    serializedPrimaryKey(serializedPrimaryKey?: boolean): PropertyChain<Value, Options>;
+    serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyChain<Value, Options>;
+    serializedName(serializedName: string): PropertyChain<Value, Options>;
+    groups(...groups: string[]): PropertyChain<Value, Options>;
+    customOrder(...customOrder: (string[] | number[] | boolean[])): PropertyChain<Value, Options>;
+    extra(extra: string): PropertyChain<Value, Options>;
+    ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): PropertyChain<Value, Options>;
+    index(index?: boolean | string): PropertyChain<Value, Options>;
+    unique(unique?: boolean | string): PropertyChain<Value, Options>;
+    comment(comment: string): PropertyChain<Value, Options>;
+    accessor(accessor?: string | boolean): PropertyChain<Value, Options>;
+    eager(eager?: boolean): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    cascade(...cascade: Cascade[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    strategy(strategy: LoadStrategy | `${LoadStrategy}`): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    filters(filters: FilterOptions): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    mappedBy(mappedBy: (keyof Value & string) | ((e: Value) => any)): HasKind<Options, '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    inversedBy(inversedBy: (keyof Value & string) | ((e: Value) => any)): HasKind<Options, 'm:1' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    owner(): HasKind<Options, '1:1' | 'm:n'> extends true ? PropertyChain<Value, Omit<Options, 'owner'> & {
+        owner: true;
+    }> : never;
+    mapToPk(): HasKind<Options, 'm:1' | '1:1'> extends true ? PropertyChain<Value, Omit<Options, 'mapToPk'> & {
+        mapToPk: true;
+    }> : never;
+    orphanRemoval(orphanRemoval?: boolean): HasKind<Options, '1:m' | '1:1'> extends true ? PropertyChain<Value, Options> : never;
+    discriminator(discriminator: string): HasKind<Options, 'm:1' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    discriminatorMap(discriminatorMap: Dictionary<string>): HasKind<Options, 'm:1' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    pivotTable(pivotTable: string): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    pivotEntity(pivotEntity: () => EntityName): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    fixedOrder(fixedOrder?: boolean): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    fixedOrderColumn(fixedOrderColumn: string): HasKind<Options, 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    array(): HasKind<Options, 'embedded' | 'enum'> extends true ? PropertyChain<Value, Omit<Options, 'array'> & {
+        array: true;
+    }> : never;
+    prefix(prefix: string | boolean): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
+    prefixMode(prefixMode: EmbeddedPrefixMode): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
+    object(object?: boolean): HasKind<Options, 'embedded'> extends true ? PropertyChain<Value, Options> : never;
+    nativeEnumName(nativeEnumName: string): HasKind<Options, 'enum'> extends true ? PropertyChain<Value, Options> : never;
+    orderBy(...orderBy: QueryOrderMap<object>[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    where(...where: FilterQuery<object>[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    joinColumn(joinColumn: string): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    joinColumns(...joinColumns: string[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    inverseJoinColumn(inverseJoinColumn: string): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    inverseJoinColumns(...inverseJoinColumns: string[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    referenceColumnName(referenceColumnName: string): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    referencedColumnNames(...referencedColumnNames: string[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    ownColumns(...ownColumns: string[]): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    targetKey(targetKey: keyof Value & string): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    deleteRule(deleteRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    updateRule(updateRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    deferMode(deferMode: DeferMode | `${DeferMode}`): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    createForeignKeyConstraint(createForeignKeyConstraint?: boolean): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+    foreignKeyName(foreignKeyName: string): HasKind<Options, 'm:1' | '1:m' | '1:1' | 'm:n'> extends true ? PropertyChain<Value, Options> : never;
+}
 /** @internal */
 export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys extends BuilderKeys> implements Record<Exclude<UniversalPropertyKeys, ExcludeKeys>, any> {
     '~options': Options;
@@ -100,8 +224,11 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Explicitly specify the auto increment of the primary key.
      */
-    autoincrement<T extends boolean = true>(autoincrement?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'autoincrement'> & {
-        autoincrement: T;
+    autoincrement(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'autoincrement'> & {
+        autoincrement: true;
+    }, IncludeKeys>, IncludeKeys>;
+    autoincrement(autoincrement: false): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'autoincrement'> & {
+        autoincrement: false;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Add the property to the `returning` statement.
@@ -150,8 +277,8 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      */
-    nullable<T extends boolean = true>(nullable?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'nullable'> & {
-        nullable: T;
+    nullable(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'nullable'> & {
+        nullable: true;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
@@ -160,8 +287,11 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
      */
-    persist<T extends boolean = true>(persist?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'persist'> & {
-        persist: T;
+    persist(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'persist'> & {
+        persist: true;
+    }, IncludeKeys>, IncludeKeys>;
+    persist(persist: false): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'persist'> & {
+        persist: false;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Set false to disable hydration of this property. Useful for persisted getters.
@@ -170,20 +300,20 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Enable `ScalarReference` wrapper for lazy values. Use this in combination with `lazy: true` to have a type-safe accessor object in place of the value.
      */
-    ref<T extends boolean = true>(ref?: T): UniversalPropertyOptionsBuilder<Value, Omit<Options, 'ref'> & {
-        ref: T;
+    ref(): UniversalPropertyOptionsBuilder<Value, Omit<Options, 'ref'> & {
+        ref: true;
     }, IncludeKeys>;
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
-    hidden<T extends boolean = true>(hidden?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'hidden'> & {
-        hidden: T;
+    hidden(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'hidden'> & {
+        hidden: true;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
      */
-    version<T extends boolean = true>(version?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'version'> & {
-        version: T;
+    version(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'version'> & {
+        version: true;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
@@ -208,16 +338,14 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      *
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
-    lazy<T extends boolean = true>(lazy?: boolean, ref?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'ref'> & {
-        ref: T;
-    }, IncludeKeys>, IncludeKeys>;
+    lazy(): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Set true to define entity's unique primary key identifier.
      *
      * @see https://mikro-orm.io/docs/decorators#primarykey
      */
-    primary<T extends boolean = true>(primary?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'primary'> & {
-        primary: T;
+    primary(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'primary'> & {
+        primary: true;
     }, IncludeKeys>, IncludeKeys>;
     /**
      * Set true to define the properties as setter. (virtual)
@@ -294,8 +422,8 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
      * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
      */
     ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
-    array<T extends boolean = true>(array?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'array'> & {
-        array: T;
+    array(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'array'> & {
+        array: true;
     }, IncludeKeys>, IncludeKeys>;
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName(nativeEnumName: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
@@ -309,8 +437,8 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /** Override the default loading strategy for this property. This option has precedence over the global `loadStrategy`, but can be overridden by `FindOptions.strategy`. */
     strategy(strategy: LoadStrategy | `${LoadStrategy}`): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Set this side as owning. Owning side is where the foreign key is defined. This option is not required if you use `inversedBy` or `mappedBy` to distinguish owning and inverse side. */
-    owner<T extends boolean = true>(owner?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'owner'> & {
-        owner: T;
+    owner(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'owner'> & {
+        owner: true;
     }, IncludeKeys>, IncludeKeys>;
     /** For polymorphic relations. Specifies the property name that stores the entity type discriminator. Defaults to the property name. */
     discriminator(discriminator: string): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
@@ -351,8 +479,8 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /** What to do when the reference to the target entity gets updated. */
     updateRule(updateRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk<T extends boolean = true>(mapToPk?: T): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'mapToPk'> & {
-        mapToPk: T;
+    mapToPk(): Pick<UniversalPropertyOptionsBuilder<Value, Omit<Options, 'mapToPk'> & {
+        mapToPk: true;
     }, IncludeKeys>, IncludeKeys>;
     /** Set the constraint type. Immediate constraints are checked for each statement, while deferred ones are only checked at the end of the transaction. Only for postgres unique constraints. */
     deferMode(deferMode: DeferMode | `${DeferMode}`): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
@@ -390,17 +518,21 @@ declare const propertyBuilders: {
     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) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
-    manyToMany: <Target extends EntityTarget>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+    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";
-    }, IncludeKeysForManyToManyOptions>;
-    manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
+    }>;
+    manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
         kind: "m:1";
-    }, IncludeKeysForManyToOneOptions>;
-    oneToMany: <Target extends EntityTarget>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
-    oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
+    }>;
+    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";
-    }, IncludeKeysForOneToOneOptions>;
+    }>;
     date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
     blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
     uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
@@ -476,17 +608,21 @@ export declare namespace defineEntity {
         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) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions, IncludeKeysForEmbeddedOptions>;
-        manyToMany: <Target extends EntityTarget>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target>, EmptyOptions & {
+        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";
-        }, IncludeKeysForManyToManyOptions>;
-        manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
+        }>;
+        manyToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => PropertyChain<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
             kind: "m:1";
-        }, IncludeKeysForManyToOneOptions>;
-        oneToMany: <Target extends EntityTarget>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<InferEntity<Target>>;
-        oneToOne: <Target extends EntityTarget | EntityTarget[]>(target: Target) => UniversalPropertyOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>, EmptyOptions & {
+        }>;
+        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";
-        }, IncludeKeysForOneToOneOptions>;
+        }>;
         date: () => UniversalPropertyOptionsBuilder<string, EmptyOptions, IncludeKeysForProperty>;
         blob: () => UniversalPropertyOptionsBuilder<NonNullable<Buffer<ArrayBufferLike> | Uint8Array<ArrayBufferLike> | null>, EmptyOptions, IncludeKeysForProperty>;
         uint8array: () => UniversalPropertyOptionsBuilder<Uint8Array<ArrayBufferLike>, EmptyOptions, IncludeKeysForProperty>;
@@ -563,8 +699,6 @@ type MaybeNullable<Value, Options> = Options extends {
 } ? Value | null | undefined : Value;
 type MaybeRelationRef<Value, Options> = Options extends {
     mapToPk: true;
-} ? Value : Options extends {
-    ref: false;
 } ? Value : Options extends {
     ref: true;
     kind: '1:1';
@@ -577,8 +711,6 @@ type MaybeRelationRef<Value, Options> = Options extends {
     kind: 'm:n';
 } ? Value extends object ? Collection<Value> : never : Value;
 type MaybeScalarRef<Value, Options> = Options extends {
-    ref: false;
-} ? Value : Options extends {
     kind: '1:1' | 'm:1' | '1:m' | 'm:n';
 } ? Value : Options extends {
     ref: true;