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

package/entity/defineEntity.d.ts

@@ -1,6 +1,6 @@
 import type { EntityManager } from '../EntityManager.js';
 import type { ColumnType, PropertyOptions, ReferenceOptions, EnumOptions, EmbeddedOptions, ManyToOneOptions, OneToManyOptions, OneToOneOptions, ManyToManyOptions } from '../metadata/types.js';
-import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever } from '../typings.js';
+import type { AnyString, GeneratedColumnCallback, Constructor, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata, PrimaryKeyProp, EntityRepositoryType, Hidden, Opt, Primary, EntityClass, EntitySchemaWithMeta, InferEntity, MaybeReturnType, Ref, IndexCallback, FormulaCallback, EntityCtor, IsNever, IWrappedEntity, DefineConfig, Config } from '../typings.js';
 import type { Raw } from '../utils/RawQueryFragment.js';
 import type { ScalarReference } from './Reference.js';
 import type { SerializeOptions } from '../serialization/EntitySerializer.js';
@@ -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)
@@ -281,7 +409,7 @@ export declare class UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys
     /**
      * Specify a custom order based on the values. (SQL only)
      */
-    customOrder(...customOrder: (string[] | number[] | boolean[])): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
+    customOrder(...customOrder: string[] | number[] | boolean[]): Pick<UniversalPropertyOptionsBuilder<Value, Options, IncludeKeys>, IncludeKeys>;
     /**
      * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
      */
@@ -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>;
@@ -373,7 +501,7 @@ export declare class OneToManyOptionsBuilderOnlyMappedBy<Value extends object> e
     kind: '1:m';
 }, IncludeKeysForOneToManyOptions> {
     /** Point to the owning side property name. */
-    mappedBy(mappedBy: (keyof Value) | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
+    mappedBy(mappedBy: keyof Value | ((e: Value) => any)): Pick<UniversalPropertyOptionsBuilder<Value, EmptyOptions & {
         kind: '1:m';
     }, IncludeKeysForOneToManyOptions>, IncludeKeysForOneToManyOptions>;
 }
@@ -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>;
@@ -421,7 +553,7 @@ declare const propertyBuilders: {
 };
 /** Own keys + base entity keys (when TBase is not `never`). Guards against `keyof never = string | number | symbol`. */
 type AllKeys<TProperties, TBase> = keyof TProperties | (IsNever<TBase> extends true ? never : keyof TBase);
-export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
+export interface EntityMetadataWithProperties<TName extends string, TTableName extends string, TProperties extends Record<string, any>, TPK extends (keyof TProperties)[] | undefined = undefined, TBase = never, TRepository = never, TForceObject extends boolean = false> extends Omit<Partial<EntityMetadata<InferEntityFromProperties<TProperties, TPK, TBase, TRepository>>>, 'properties' | 'extends' | 'primaryKeys' | 'hooks' | 'discriminatorColumn' | 'versionProperty' | 'concurrencyCheckKeys' | 'serializedPrimaryKey' | 'indexes' | 'uniques' | 'repository' | 'orderBy'> {
     name: TName;
     tableName?: TTableName;
     extends?: {
@@ -431,6 +563,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
     primaryKeys?: TPK & InferPrimaryKey<TProperties>[];
     hooks?: DefineEntityHooks;
     repository?: () => TRepository;
+    forceObject?: TForceObject;
     inheritance?: 'tpt';
     orderBy?: {
         [K in Extract<AllKeys<TProperties, TBase>, string>]?: QueryOrderKeysFlat;
@@ -456,7 +589,7 @@ export interface EntityMetadataWithProperties<TName extends string, TTableName e
         deferMode?: DeferMode | `${DeferMode}`;
     }[];
 }
-export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository>, TBase, TProperties>;
+export declare function defineEntity<const TName extends string, const TTableName extends string, const TProperties extends Record<string, any>, const TPK extends (keyof TProperties)[] | undefined = undefined, const TBase = never, const TRepository = never, const TForceObject extends boolean = false>(meta: EntityMetadataWithProperties<TName, TTableName, TProperties, TPK, TBase, TRepository, TForceObject>): EntitySchemaWithMeta<TName, TTableName, InferEntityFromProperties<TProperties, TPK, TBase, TRepository, TForceObject>, TBase, TProperties>;
 export declare function defineEntity<const TEntity = any, const TProperties extends Record<string, any> = Record<string, any>, const TClassName extends string = string, const TTableName extends string = string, const TBase = never, const TClass extends EntityCtor = EntityCtor<TEntity>>(meta: Omit<Partial<EntityMetadata<TEntity>>, 'properties' | 'extends' | 'className' | 'tableName' | 'hooks'> & {
     class: TClass;
     className?: TClassName;
@@ -476,17 +609,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>;
@@ -522,23 +659,34 @@ export interface DefineEntityHooks<T = any> {
 }
 type PropertyValueType = PropertyOptions<any>['type'];
 type InferPropertyValueType<T extends PropertyValueType> = T extends string ? InferTypeByString<T> : T extends NumberConstructor ? number : T extends StringConstructor ? string : T extends BooleanConstructor ? boolean : T extends DateConstructor ? Date : T extends ArrayConstructor ? string[] : T extends Constructor<infer TType> ? TType extends Type<infer TValue, any> ? NonNullable<TValue> : TType : T extends Type<infer TValue, any> ? NonNullable<TValue> : any;
-type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<typeof types[T]> : InferColumnType<T>;
+type InferTypeByString<T extends string> = T extends keyof typeof types ? InferJSType<(typeof types)[T]> : InferColumnType<T>;
 type InferJSType<T> = T extends typeof Type<infer TValue, any> ? NonNullable<TValue> : never;
 type InferColumnType<T extends string> = T extends 'int' | 'int4' | 'integer' | 'bigint' | 'int8' | 'int2' | 'tinyint' | 'smallint' | 'mediumint' ? number : T extends 'double' | 'double precision' | 'real' | 'float8' | 'decimal' | 'numeric' | 'float' | 'float4' ? number : T extends 'datetime' | 'time' | 'time with time zone' | 'timestamp' | 'timestamp with time zone' | 'timetz' | 'timestamptz' | 'date' | 'interval' ? Date : T extends 'ObjectId' | 'objectId' | 'character varying' | 'varchar' | 'char' | 'character' | 'uuid' | 'text' | 'tinytext' | 'mediumtext' | 'longtext' | 'enum' ? string : T extends 'boolean' | 'bool' | 'bit' ? boolean : T extends 'blob' | 'tinyblob' | 'mediumblob' | 'longblob' | 'bytea' ? Buffer : T extends 'point' | 'line' | 'lseg' | 'box' | 'circle' | 'path' | 'polygon' | 'geometry' ? number[] : T extends 'tsvector' | 'tsquery' ? string[] : T extends 'json' | 'jsonb' ? any : any;
-export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never> = {
+type BaseEntityMethodKeys = 'toObject' | 'toPOJO' | 'serialize' | 'assign' | 'populate' | 'init' | 'toReference';
+export type InferEntityFromProperties<Properties extends Record<string, any>, PK extends (keyof Properties)[] | undefined = undefined, Base = never, Repository = never, ForceObject extends boolean = false> = (IsNever<Base> extends true ? {} : Base extends {
+    toObject(...args: any[]): any;
+} ? Pick<IWrappedEntity<{
     -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
 } & {
     [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
 } & (IsNever<Repository> extends true ? {} : {
     [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
-}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>);
+}) & Omit<Base, typeof PrimaryKeyProp>>, BaseEntityMethodKeys> : {}) & {
+    -readonly [K in keyof Properties]: InferBuilderValue<MaybeReturnType<Properties[K]>>;
+} & {
+    [PrimaryKeyProp]?: InferCombinedPrimaryKey<Properties, PK, Base>;
+} & (IsNever<Repository> extends true ? {} : {
+    [EntityRepositoryType]?: Repository extends Constructor<infer R> ? R : Repository;
+}) & (IsNever<Base> extends true ? {} : Omit<Base, typeof PrimaryKeyProp>) & (ForceObject extends true ? {
+    [Config]?: DefineConfig<{
+        forceObject: true;
+    }>;
+} : {});
 type InferCombinedPrimaryKey<Properties extends Record<string, any>, PK, Base> = PK extends undefined ? CombinePrimaryKeys<InferPrimaryKey<Properties>, ExtractBasePrimaryKey<Base>> : PK;
 type ExtractBasePrimaryKey<Base> = Base extends {
     [PrimaryKeyProp]?: infer BasePK;
 } ? BasePK : never;
-type CombinePrimaryKeys<ChildPK, BasePK> = [
-    ChildPK
-] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
+type CombinePrimaryKeys<ChildPK, BasePK> = [ChildPK] extends [never] ? BasePK : [BasePK] extends [never] ? IsUnion<ChildPK> extends true ? ChildPK[] : ChildPK : ChildPK | BasePK;
 export type InferPrimaryKey<Properties extends Record<string, any>> = {
     [K in keyof Properties]: MaybeReturnType<Properties[K]> extends {
         '~options': {
@@ -563,8 +711,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 +723,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;

package/entity/defineEntity.js

@@ -1,5 +1,7 @@
 import { types } from '../types/index.js';
 import { EntitySchema } from '../metadata/EntitySchema.js';
+// Parameter-level sync assertion lives in tests/defineEntity.test.ts to avoid
+// instantiating the full builder class in production builds (~680 instantiations).
 /** @internal */
 export class UniversalPropertyOptionsBuilder {
     '~options';
@@ -82,9 +84,6 @@ export class UniversalPropertyOptionsBuilder {
     scale(scale) {
         return this.assignOptions({ scale });
     }
-    /**
-     * Explicitly specify the auto increment of the primary key.
-     */
     autoincrement(autoincrement = true) {
         return this.assignOptions({ autoincrement });
     }
@@ -143,8 +142,8 @@ export class UniversalPropertyOptionsBuilder {
     /**
      * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
      */
-    nullable(nullable = true) {
-        return this.assignOptions({ nullable });
+    nullable() {
+        return this.assignOptions({ nullable: true });
     }
     /**
      * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
@@ -152,9 +151,6 @@ export class UniversalPropertyOptionsBuilder {
     unsigned(unsigned = true) {
         return this.assignOptions({ unsigned });
     }
-    /**
-     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
-     */
     persist(persist = true) {
         return this.assignOptions({ persist });
     }
@@ -167,20 +163,20 @@ export class UniversalPropertyOptionsBuilder {
     /**
      * 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(ref = true) {
-        return this.assignOptions({ ref });
+    ref() {
+        return this.assignOptions({ ref: true });
     }
     /**
      * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
      */
-    hidden(hidden = true) {
-        return this.assignOptions({ hidden });
+    hidden() {
+        return this.assignOptions({ hidden: true });
     }
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
      */
-    version(version = true) {
-        return this.assignOptions({ version });
+    version() {
+        return this.assignOptions({ version: true });
     }
     /**
      * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
@@ -213,16 +209,16 @@ export class UniversalPropertyOptionsBuilder {
      *
      * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
      */
-    lazy(lazy = true, ref = true) {
-        return this.assignOptions({ lazy, ref });
+    lazy() {
+        return this.assignOptions({ lazy: true });
     }
     /**
      * Set true to define entity's unique primary key identifier.
      *
      * @see https://mikro-orm.io/docs/decorators#primarykey
      */
-    primary(primary = true) {
-        return this.assignOptions({ primary });
+    primary() {
+        return this.assignOptions({ primary: true });
     }
     /**
      * Set true to define the properties as setter. (virtual)
@@ -321,8 +317,8 @@ export class UniversalPropertyOptionsBuilder {
     ignoreSchemaChanges(...ignoreSchemaChanges) {
         return this.assignOptions({ ignoreSchemaChanges });
     }
-    array(array = true) {
-        return this.assignOptions({ array });
+    array() {
+        return this.assignOptions({ array: true });
     }
     /** for postgres, by default it uses text column with check constraint */
     nativeEnumName(nativeEnumName) {
@@ -350,8 +346,8 @@ export class UniversalPropertyOptionsBuilder {
         return this.assignOptions({ strategy });
     }
     /** 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(owner = true) {
-        return this.assignOptions({ owner });
+    owner() {
+        return this.assignOptions({ owner: true });
     }
     /** For polymorphic relations. Specifies the property name that stores the entity type discriminator. Defaults to the property name. */
     discriminator(discriminator) {
@@ -430,8 +426,8 @@ export class UniversalPropertyOptionsBuilder {
         return this.assignOptions({ updateRule });
     }
     /** Map this relation to the primary key value instead of an entity. */
-    mapToPk(mapToPk = true) {
-        return this.assignOptions({ mapToPk });
+    mapToPk() {
+        return this.assignOptions({ mapToPk: true });
     }
     /** 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) {

package/entity/utils.js

@@ -17,15 +17,17 @@ function expandNestedPopulate(parentProp, parts, strategy, all) {
  * @internal
  */
 export function expandDotPaths(meta, populate, normalized = false) {
-    const ret = normalized ? populate : Utils.asArray(populate).map(field => {
-        if (typeof field === 'string') {
-            return { field };
-        }
-        /* v8 ignore next */
-        return typeof field === 'boolean' || field.field === PopulatePath.ALL
-            ? { all: !!field, field: meta.primaryKeys[0] }
-            : field;
-    });
+    const ret = normalized
+        ? populate
+        : Utils.asArray(populate).map(field => {
+            if (typeof field === 'string') {
+                return { field };
+            }
+            /* v8 ignore next */
+            return typeof field === 'boolean' || field.field === PopulatePath.ALL
+                ? { all: !!field, field: meta.primaryKeys[0] }
+                : field;
+        });
     for (const p of ret) {
         if (!p.field.includes('.')) {
             continue;
@@ -35,8 +37,8 @@ export function expandDotPaths(meta, populate, normalized = false) {
         p.children ??= [];
         const prop = meta.properties[p.field];
         if (parts[0] === PopulatePath.ALL) {
-            prop.targetMeta.props
-                .filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
+            prop
+                .targetMeta.props.filter(prop => prop.lazy || prop.kind !== ReferenceKind.SCALAR)
                 .forEach(prop => p.children.push({ field: prop.name, strategy: p.strategy }));
         }
         else if (prop.kind === ReferenceKind.EMBEDDED) {
@@ -67,6 +69,21 @@ export function getLoadingStrategy(strategy, kind) {
     }
     return strategy;
 }
+function findPopulateEntry(populate, parts) {
+    let current = populate;
+    for (let i = 0; i < parts.length; i++) {
+        const entry = current.find(p => p.field.split(':')[0] === parts[i]);
+        if (!entry) {
+            return undefined;
+        }
+        if (i === parts.length - 1) {
+            return entry;
+        }
+        current = (entry.children ?? []);
+    }
+    /* v8 ignore next */
+    return undefined;
+}
 /**
  * Applies per-relation overrides from `populateHints` to the normalized populate tree.
  * @internal
@@ -85,18 +102,3 @@ export function applyPopulateHints(populate, hints) {
         }
     }
 }
-function findPopulateEntry(populate, parts) {
-    let current = populate;
-    for (let i = 0; i < parts.length; i++) {
-        const entry = current.find(p => p.field.split(':')[0] === parts[i]);
-        if (!entry) {
-            return undefined;
-        }
-        if (i === parts.length - 1) {
-            return entry;
-        }
-        current = (entry.children ?? []);
-    }
-    /* v8 ignore next */
-    return undefined;
-}