@mikro-orm/core 6.4.17-dev.24 → 6.4.17-dev.26

package/entity/defineEntity.d.ts

@@ -0,0 +1,528 @@
+import type { EntityManager } from '../EntityManager';
+import type { ColumnType, PropertyOptions, ReferenceOptions } from '../decorators/Property';
+import type { EnumOptions } from '../decorators/Enum';
+import type { EmbeddedOptions, EmbeddedPrefixMode } from '../decorators/Embedded';
+import type { ManyToOneOptions } from '../decorators/ManyToOne';
+import type { OneToManyOptions } from '../decorators/OneToMany';
+import type { OneToOneOptions } from '../decorators/OneToOne';
+import type { ManyToManyOptions } from '../decorators/ManyToMany';
+import type { AnyString, GeneratedColumnCallback, Constructor, Opt, Hidden, CheckCallback, FilterQuery, EntityName, Dictionary, EntityMetadata } from '../typings';
+import type { Reference, ScalarReference } from './Reference';
+import type { SerializeOptions } from '../serialization/EntitySerializer';
+import type { Cascade, DeferMode, LoadStrategy, QueryOrderMap } from '../enums';
+import type { Collection } from './Collection';
+import type { IType, Type } from '../types/Type';
+import { types } from '../types';
+import { EntitySchema } from '../metadata/EntitySchema';
+declare class PropertyOptionsBuilder<Value> {
+    '~options': PropertyOptions<any>;
+    '~type'?: {
+        value: Value;
+    };
+    constructor(options: PropertyOptionsBuilder<Value>['~options']);
+    /**
+     * Alias for `fieldName`.
+     */
+    name(name: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify database column name for this property.
+     *
+     * @see https://mikro-orm.io/docs/naming-strategy
+     */
+    fieldName(fieldName: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify database column names for this property.
+     * Same as `fieldName` but for composite FKs.
+     *
+     * @see https://mikro-orm.io/docs/naming-strategy
+     */
+    fieldNames(...fieldNames: string[]): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is only for simple properties represented by a single column. (SQL only)
+     */
+    columnType(columnType: ColumnType | AnyString): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is suitable for composite keys, where one property is represented by multiple columns. (SQL only)
+     */
+    columnTypes(...columnTypes: (ColumnType | AnyString)[]): PropertyOptionsBuilder<Value>;
+    /**
+     * Explicitly specify the runtime type.
+     *
+     * @see https://mikro-orm.io/docs/metadata-providers
+     * @see https://mikro-orm.io/docs/custom-types
+     */
+    type<TType extends PropertyValueType>(type: TType): PropertyOptionsBuilder<InferPropertyValueType<TType>>;
+    /**
+     * Runtime type of the property. This is the JS type that your property is mapped to, e.g. `string` or `number`, and is normally inferred automatically via `reflect-metadata`.
+     * In some cases, the inference won't work, and you might need to specify the `runtimeType` explicitly - the most common one is when you use a union type with null like `foo: number | null`.
+     */
+    runtimeType(runtimeType: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Set length of database column, used for datetime/timestamp/varchar column types for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    length(length: number): PropertyOptionsBuilder<Value>;
+    /**
+     * Set precision of database column to represent the number of significant digits. (SQL only)
+     */
+    precision(precision: number): PropertyOptionsBuilder<Value>;
+    /**
+     * Set scale of database column to represents the number of digits after the decimal point. (SQL only)
+     */
+    scale(scale: number): PropertyOptionsBuilder<Value>;
+    /**
+     * Explicitly specify the auto increment of the primary key.
+     */
+    autoincrement(autoincrement?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Add the property to the `returning` statement.
+     */
+    returning(returning?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Automatically set the property value when entity gets created, executed during flush operation.
+     * @param entity
+     */
+    onCreate(onCreate: (entity: any, em: EntityManager) => Value): PropertyOptionsBuilder<Opt<Value>>;
+    /**
+     * Automatically update the property value every time entity gets updated, executed during flush operation.
+     * @param entity
+     */
+    onUpdate(onUpdate: (entity: any, em: EntityManager) => Value): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
+     * This is a runtime value, assignable to the entity property. (SQL only)
+     */
+    default(defaultValue: string | string[] | number | number[] | boolean | null): PropertyOptionsBuilder<Opt<Value>>;
+    /**
+     * Specify SQL functions for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * Since v4 you should use defaultRaw for SQL functions. e.g. now()
+     */
+    defaultRaw(defaultRaw: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to map some SQL snippet for the entity.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
+     */
+    formula(formula: string | ((alias: string) => string)): PropertyOptionsBuilder<Value>;
+    /**
+     * For generated columns. This will be appended to the column type after the `generated always` clause.
+     */
+    generated(generated: string | GeneratedColumnCallback<any>): PropertyOptionsBuilder<Value>;
+    /**
+     * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
+     */
+    nullable<T extends boolean = true>(nullable?: T): PropertyOptionsBuilder<T extends true ? Value extends ScalarReference<infer InnerValue> ? ScalarReference<InnerValue | null> : Value | null | undefined : NonNullable<Value>>;
+    /**
+     * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    unsigned(unsigned?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
+     */
+    persist(persist?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set false to disable hydration of this property. Useful for persisted getters.
+     */
+    hydrate(hydrate?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * 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): PropertyOptionsBuilder<T extends true ? ScalarReference<Value> : UnwrapRef<Value>>;
+    /**
+     * Set false to disable change tracking on a property level.
+     *
+     * @see https://mikro-orm.io/docs/unit-of-work#change-tracking-and-performance-considerations
+     */
+    trackChanges(trackChanges?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
+     */
+    hidden<T extends boolean = true>(hidden?: T): PropertyOptionsBuilder<T extends true ? Hidden<Value> : Value>;
+    /**
+     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via version field. (SQL only)
+     */
+    version(version?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
+     */
+    concurrencyCheck(concurrencyCheck?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Explicitly specify index on a property.
+     */
+    index(index?: boolean | string): PropertyOptionsBuilder<Value>;
+    /**
+     * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    unique(unique?: boolean | string): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify column with check constraints. (Postgres driver only)
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#check-constraints
+     */
+    check(check: string | CheckCallback<any>): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to omit the property from the select clause for lazy loading.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
+     */
+    lazy<T extends boolean = true>(lazy?: boolean, ref?: T): PropertyOptionsBuilder<T extends true ? ScalarReference<Value> : UnwrapRef<Value>>;
+    /**
+     * Set true to define entity's unique primary key identifier.
+     *
+     * @see https://mikro-orm.io/docs/decorators#primarykey
+     */
+    primary(primary?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set true to define the properties as setter. (virtual)
+     *
+     * @example
+     * ```
+     * @Property({ setter: true })
+     * set address(value: string) {
+     *     this._address = value.toLocaleLowerCase();
+     * }
+     * ```
+     */
+    setter(setter?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set true to define the properties as getter. (virtual)
+     *
+     * @example
+     * ```
+     * @Property({ getter: true })
+     * get fullName() {
+     *   return this.firstName + this.lastName;
+     * }
+     * ```
+     */
+    getter(getter?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * When defining a property over a method (not a getter, a regular function), you can use this option to point
+     * to the method name.
+     *
+     * @example
+     * ```
+     * @Property({ getter: true })
+     * getFullName() {
+     *   return this.firstName + this.lastName;
+     * }
+     * ```
+     */
+    getterName(getterName: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to define serialized primary key for MongoDB. (virtual)
+     * Alias for `@SerializedPrimaryKey()` decorator.
+     *
+     * @see https://mikro-orm.io/docs/decorators#serializedprimarykey
+     */
+    serializedPrimaryKey(serializedPrimaryKey?: boolean): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to use serialize property. Allow to specify a callback that will be used when serializing a property.
+     *
+     * @see https://mikro-orm.io/docs/serializing#property-serializers
+     */
+    serializer(serializer: (value: Value, options?: SerializeOptions<any>) => any): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify name of key for the serialized value.
+     */
+    serializedName(serializedName: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify serialization groups for `serialize()` calls. If a property does not specify any group, it will be included,
+     * otherwise only properties with a matching group are included.
+     */
+    groups(...groups: string[]): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify a custom order based on the values. (SQL only)
+     */
+    customOrder(...customOrder: (string[] | number[] | boolean[])): PropertyOptionsBuilder<Value>;
+    /**
+     * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    comment(comment: string): PropertyOptionsBuilder<Value>;
+    /** mysql only */
+    extra(extra: string): PropertyOptionsBuilder<Value>;
+    /**
+     * Set to avoid a perpetual diff from the {@link https://mikro-orm.io/docs/schema-generator Schema Generator} when columns are generated.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
+     */
+    ignoreSchemaChanges(...ignoreSchemaChanges: ('type' | 'extra' | 'default')[]): PropertyOptionsBuilder<Value>;
+    /**
+     * Set the TypeScript type of the property.
+     */
+    $type<T>(): PropertyOptionsBuilder<T>;
+    /**
+     * Set the TypeScript type for custom types that map to objects.
+     * This method provides type safety for custom types by specifying the runtime type,
+     * raw database value type, and optional serialized type.
+     *
+     * @template Runtime - The runtime type that the property will have in JavaScript
+     * @template Raw - The raw value type as stored in the database
+     * @template Serialized - The type when serialized (defaults to Raw)
+     * @returns PropertyOptionsBuilder with IType wrapper for type safety
+     */
+    $type<Runtime, Raw, Serialized = Raw>(): PropertyOptionsBuilder<IType<Runtime, Raw, Serialized>>;
+}
+declare class EnumOptionsBuilder<Value> extends PropertyOptionsBuilder<Value> {
+    '~options': {
+        enum: true;
+    } & EnumOptions<any>;
+    constructor(options: EnumOptionsBuilder<Value>['~options']);
+    array<T extends boolean = true>(array?: T): EnumOptionsBuilder<T extends true ? Value[] : UnwrapArray<Value>>;
+    /** for postgres, by default it uses text column with check constraint */
+    nativeEnumName(nativeEnumName: string): EnumOptionsBuilder<Value>;
+}
+declare class EmbeddedOptionsBuilder<Value> extends PropertyOptionsBuilder<Value> {
+    '~options': ({
+        kind: 'embedded';
+        entity: () => EntitySchema<any, any> | EntitySchema<any, any>[];
+    } & EmbeddedOptions<any, any> & PropertyOptions<any>);
+    constructor(options: EmbeddedOptionsBuilder<Value>['~options']);
+    prefix(prefix: string): EmbeddedOptionsBuilder<Value>;
+    prefixMode(prefixMode: EmbeddedPrefixMode): EmbeddedOptionsBuilder<Value>;
+    object(object?: boolean): EmbeddedOptionsBuilder<Value>;
+    array<T extends boolean = true>(array?: T): EmbeddedOptionsBuilder<T extends true ? Value[] : UnwrapArray<Value>>;
+}
+declare class ReferenceOptionsBuilder<Value extends object> extends PropertyOptionsBuilder<Value> {
+    '~options': ReferenceOptions<any, any>;
+    constructor(options: ReferenceOptionsBuilder<Value>['~options']);
+    /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
+    cascade(...cascade: Cascade[]): ReferenceOptionsBuilder<Value>;
+    /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
+    eager(eager?: boolean): ReferenceOptionsBuilder<Value>;
+    /** 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}`): ReferenceOptionsBuilder<Value>;
+    /**
+     * @internal
+     * re-declare to override type inference
+     */
+    ref(ref?: boolean): ReferenceOptionsBuilder<any>;
+    /**
+     * @internal
+     * re-declare to override type inference
+     */
+    primary(primary?: boolean): ReferenceOptionsBuilder<any>;
+}
+declare class ManyToManyOptionsBuilder<TargetValue extends object> extends ReferenceOptionsBuilder<TargetValue> {
+    '~options': ({
+        kind: 'm:n';
+        entity: () => EntitySchema<any, any>;
+    } & ManyToManyOptions<any, UnwrapCollection<TargetValue>>);
+    constructor(options: ManyToManyOptionsBuilder<TargetValue>['~options']);
+    /** 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?: boolean): ManyToManyOptionsBuilder<TargetValue>;
+    /** Point to the inverse side property name. */
+    inversedBy(inversedBy: (string & keyof UnwrapCollection<TargetValue>) | ((e: UnwrapCollection<TargetValue>) => any)): ManyToManyOptionsBuilder<TargetValue>;
+    /** Point to the owning side property name. */
+    mappedBy(mappedBy: string | ((e: any) => any)): ManyToManyOptionsBuilder<TargetValue>;
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
+    where(...where: FilterQuery<object>[]): ManyToManyOptionsBuilder<TargetValue>;
+    /** Set default ordering. */
+    orderBy(...orderBy: QueryOrderMap<object>[]): ManyToManyOptionsBuilder<TargetValue>;
+    /** Force stable insertion order of items in the collection (see {@doclink collections | Collections}). */
+    fixedOrder(fixedOrder?: boolean): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override default order column name (`id`) for fixed ordering. */
+    fixedOrderColumn(fixedOrderColumn: string): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
+    pivotTable(pivotTable: string): ManyToManyOptionsBuilder<TargetValue>;
+    /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
+    pivotEntity(pivotEntity: string | (() => EntityName<any>)): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    joinColumn(joinColumn: string): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    joinColumns(...joinColumns: string[]): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    inverseJoinColumn(inverseJoinColumn: string): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    inverseJoinColumns(...inverseJoinColumns: string[]): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    referenceColumnName(referenceColumnName: string): ManyToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames(...referencedColumnNames: string[]): ManyToManyOptionsBuilder<TargetValue>;
+    /** What to do when the target entity gets deleted. */
+    deleteRule(deleteRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): ManyToManyOptionsBuilder<TargetValue>;
+    /** What to do when the reference to the target entity gets updated. */
+    updateRule(updateRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): ManyToManyOptionsBuilder<TargetValue>;
+}
+declare class ManyToOneOptionsBuilder<TargetValue extends object> extends ReferenceOptionsBuilder<TargetValue> {
+    '~options': ({
+        kind: 'm:1';
+        entity: () => EntitySchema<any, any>;
+    } & ManyToOneOptions<any, UnwrapRef<TargetValue>>);
+    constructor(options: ManyToOneOptionsBuilder<TargetValue>['~options']);
+    /** Point to the inverse side property name. */
+    inversedBy(inversedBy: (string & keyof UnwrapRef<TargetValue>) | ((e: UnwrapRef<TargetValue>) => any)): ManyToOneOptionsBuilder<TargetValue>;
+    /** Wrap the entity in {@apilink Reference} wrapper. */
+    ref<T extends boolean = true>(ref?: T): ManyToOneOptionsBuilder<T extends true ? Reference<TargetValue> : UnwrapRef<TargetValue>>;
+    /** Use this relation as a primary key. */
+    primary(primary?: boolean): ManyToOneOptionsBuilder<TargetValue>;
+    /** Map this relation to the primary key value instead of an entity. */
+    mapToPk(mapToPk?: boolean): ManyToOneOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    joinColumn(joinColumn: string): ManyToOneOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    joinColumns(...joinColumns: string[]): ManyToOneOptionsBuilder<TargetValue>;
+    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
+    ownColumns(...ownColumns: string[]): ManyToOneOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    referenceColumnName(referenceColumnName: string): ManyToOneOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames(...referencedColumnNames: string[]): ManyToOneOptionsBuilder<TargetValue>;
+    /** What to do when the target entity gets deleted. */
+    deleteRule(deleteRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): ManyToOneOptionsBuilder<TargetValue>;
+    /** What to do when the reference to the target entity gets updated. */
+    updateRule(updateRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): ManyToOneOptionsBuilder<TargetValue>;
+    /** 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}`): ManyToOneOptionsBuilder<TargetValue>;
+}
+declare class OneToManyOptionsBuilder<TargetValue extends object> extends ReferenceOptionsBuilder<TargetValue> {
+    '~options': ({
+        kind: '1:m';
+        entity: () => EntitySchema<TargetValue>;
+    } & OneToManyOptions<any, UnwrapCollection<TargetValue>>);
+    constructor(options: OneToManyOptionsBuilder<TargetValue>['~options']);
+    /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
+    orphanRemoval(orphanRemoval?: boolean): OneToManyOptionsBuilder<TargetValue>;
+    /** Set default ordering. */
+    orderBy(orderBy: QueryOrderMap<UnwrapCollection<TargetValue>> | QueryOrderMap<UnwrapCollection<TargetValue>>[]): OneToManyOptionsBuilder<TargetValue>;
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
+    where(where: FilterQuery<UnwrapCollection<TargetValue>>): OneToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    joinColumn(joinColumn: string): OneToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    joinColumns(...joinColumns: string[]): OneToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    inverseJoinColumn(inverseJoinColumn: string): OneToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    inverseJoinColumns(...inverseJoinColumns: string[]): OneToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    referenceColumnName(referenceColumnName: string): OneToManyOptionsBuilder<TargetValue>;
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames(...referencedColumnNames: string[]): OneToManyOptionsBuilder<TargetValue>;
+}
+declare class OneToManyOptionsBuilderOnlyMappedBy<TargetValue extends object> {
+    '~options': ({
+        kind: '1:m';
+        entity: () => EntitySchema<TargetValue>;
+    } & Omit<OneToManyOptions<any, UnwrapCollection<TargetValue>>, 'mappedBy'>);
+    constructor(options: OneToManyOptionsBuilderOnlyMappedBy<TargetValue>['~options']);
+    /** Point to the owning side property name. */
+    mappedBy(mappedBy: (AnyString & keyof UnwrapCollection<TargetValue>) | ((e: UnwrapCollection<TargetValue>) => any)): OneToManyOptionsBuilder<TargetValue>;
+}
+declare class OneToOneOptionsBuilder<TargetValue extends object> extends ReferenceOptionsBuilder<TargetValue> {
+    '~options': ({
+        kind: '1:1';
+        entity: () => EntitySchema<any, any>;
+    } & OneToOneOptions<any, UnwrapRef<TargetValue>>);
+    constructor(options: OneToOneOptionsBuilder<TargetValue>['~options']);
+    /** 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?: boolean): OneToOneOptionsBuilder<TargetValue>;
+    /** Point to the inverse side property name. */
+    inversedBy(inversedBy: (string & keyof UnwrapRef<TargetValue>) | ((e: UnwrapRef<TargetValue>) => any)): OneToOneOptionsBuilder<TargetValue>;
+    /** Wrap the entity in {@apilink Reference} wrapper. */
+    ref<T extends boolean = true>(ref?: T): OneToOneOptionsBuilder<T extends true ? Reference<TargetValue> : UnwrapRef<TargetValue>>;
+    /** Use this relation as a primary key. */
+    primary(primary?: boolean): OneToOneOptionsBuilder<TargetValue>;
+    /** Map this relation to the primary key value instead of an entity. */
+    mapToPk(mapToPk?: boolean): OneToOneOptionsBuilder<TargetValue>;
+    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
+    ownColumns(...ownColumns: string[]): OneToOneOptionsBuilder<TargetValue>;
+    /** What to do when the target entity gets deleted. */
+    deleteRule(deleteRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): OneToOneOptionsBuilder<TargetValue>;
+    /** What to do when the reference to the target entity gets updated. */
+    updateRule(updateRule: 'cascade' | 'no action' | 'set null' | 'set default' | AnyString): OneToOneOptionsBuilder<TargetValue>;
+    /** 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}`): OneToOneOptionsBuilder<TargetValue>;
+}
+declare const propertyBuilders: {
+    json: <T>() => PropertyOptionsBuilder<T>;
+    formula: <T>(formula: string | ((alias: string) => string)) => PropertyOptionsBuilder<T>;
+    type: <T extends PropertyValueType>(type: T) => PropertyOptionsBuilder<InferPropertyValueType<T>>;
+    enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => EnumOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T>;
+    embedded: <Target extends EntitySchema<any, any> | EntitySchema<any, any>[]>(target: Target) => EmbeddedOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>>;
+    manyToMany: <Target extends EntitySchema<any, any>>(target: Target) => ManyToManyOptionsBuilder<Collection<InferEntity<Target>, object>>;
+    manyToOne: <Target extends EntitySchema<any, any>>(target: Target) => ManyToOneOptionsBuilder<Reference<InferEntity<Target>>>;
+    oneToMany: <Target extends EntitySchema<any, any>>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<Collection<InferEntity<Target>, object>>;
+    oneToOne: <Target extends EntitySchema<any, any>>(target: Target) => OneToOneOptionsBuilder<Reference<InferEntity<Target>>>;
+    date: () => PropertyOptionsBuilder<string>;
+    time: () => PropertyOptionsBuilder<any>;
+    datetime: () => PropertyOptionsBuilder<Date>;
+    bigint: () => PropertyOptionsBuilder<NonNullable<string | number | bigint | null | undefined>>;
+    blob: () => PropertyOptionsBuilder<NonNullable<Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | null>>;
+    uint8array: () => PropertyOptionsBuilder<Uint8Array<ArrayBufferLike>>;
+    array: () => PropertyOptionsBuilder<unknown[]>;
+    enumArray: () => PropertyOptionsBuilder<(string | number)[]>;
+    integer: () => PropertyOptionsBuilder<number>;
+    smallint: () => PropertyOptionsBuilder<number>;
+    tinyint: () => PropertyOptionsBuilder<number>;
+    mediumint: () => PropertyOptionsBuilder<number>;
+    float: () => PropertyOptionsBuilder<number>;
+    double: () => PropertyOptionsBuilder<NonNullable<string | number>>;
+    boolean: () => PropertyOptionsBuilder<number>;
+    decimal: () => PropertyOptionsBuilder<NonNullable<string | number>>;
+    character: () => PropertyOptionsBuilder<string>;
+    string: () => PropertyOptionsBuilder<string>;
+    uuid: () => PropertyOptionsBuilder<string>;
+    text: () => PropertyOptionsBuilder<string>;
+    interval: () => PropertyOptionsBuilder<string>;
+    unknown: () => PropertyOptionsBuilder<{}>;
+};
+export declare function defineEntity<Properties extends Record<string, any>>(meta: Omit<Partial<EntityMetadata<InferEntityFromProperties<Properties>>>, 'properties' | 'extends'> & {
+    name: string;
+    properties: Properties | ((properties: typeof propertyBuilders) => Properties);
+}): EntitySchema<InferEntityFromProperties<Properties>, never>;
+export declare namespace defineEntity {
+    var properties: {
+        json: <T>() => PropertyOptionsBuilder<T>;
+        formula: <T>(formula: string | ((alias: string) => string)) => PropertyOptionsBuilder<T>;
+        type: <T extends PropertyValueType>(type: T) => PropertyOptionsBuilder<InferPropertyValueType<T>>;
+        enum: <const T extends (number | string)[] | (() => Dictionary)>(items?: T) => EnumOptionsBuilder<T extends () => Dictionary ? ValueOf<ReturnType<T>> : T extends (infer Value)[] ? Value : T>;
+        embedded: <Target extends EntitySchema<any, any> | EntitySchema<any, any>[]>(target: Target) => EmbeddedOptionsBuilder<InferEntity<Target extends (infer T)[] ? T : Target>>;
+        manyToMany: <Target extends EntitySchema<any, any>>(target: Target) => ManyToManyOptionsBuilder<Collection<InferEntity<Target>, object>>;
+        manyToOne: <Target extends EntitySchema<any, any>>(target: Target) => ManyToOneOptionsBuilder<Reference<InferEntity<Target>>>;
+        oneToMany: <Target extends EntitySchema<any, any>>(target: Target) => OneToManyOptionsBuilderOnlyMappedBy<Collection<InferEntity<Target>, object>>;
+        oneToOne: <Target extends EntitySchema<any, any>>(target: Target) => OneToOneOptionsBuilder<Reference<InferEntity<Target>>>;
+        date: () => PropertyOptionsBuilder<string>;
+        time: () => PropertyOptionsBuilder<any>;
+        datetime: () => PropertyOptionsBuilder<Date>;
+        bigint: () => PropertyOptionsBuilder<NonNullable<string | number | bigint | null | undefined>>;
+        blob: () => PropertyOptionsBuilder<NonNullable<Uint8Array<ArrayBufferLike> | Buffer<ArrayBufferLike> | null>>;
+        uint8array: () => PropertyOptionsBuilder<Uint8Array<ArrayBufferLike>>;
+        array: () => PropertyOptionsBuilder<unknown[]>;
+        enumArray: () => PropertyOptionsBuilder<(string | number)[]>;
+        integer: () => PropertyOptionsBuilder<number>;
+        smallint: () => PropertyOptionsBuilder<number>;
+        tinyint: () => PropertyOptionsBuilder<number>;
+        mediumint: () => PropertyOptionsBuilder<number>;
+        float: () => PropertyOptionsBuilder<number>;
+        double: () => PropertyOptionsBuilder<NonNullable<string | number>>;
+        boolean: () => PropertyOptionsBuilder<number>;
+        decimal: () => PropertyOptionsBuilder<NonNullable<string | number>>;
+        character: () => PropertyOptionsBuilder<string>;
+        string: () => PropertyOptionsBuilder<string>;
+        uuid: () => PropertyOptionsBuilder<string>;
+        text: () => PropertyOptionsBuilder<string>;
+        interval: () => PropertyOptionsBuilder<string>;
+        unknown: () => PropertyOptionsBuilder<{}>;
+    };
+}
+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 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;
+type InferEntityFromProperties<Properties extends Record<string, any>> = {
+    -readonly [K in keyof Properties]: Properties[K] extends (() => any) ? InferBuilderValue<ReturnType<Properties[K]>> : InferBuilderValue<Properties[K]>;
+};
+type InferBuilderValue<Builder> = Builder extends {
+    '~type'?: {
+        value: infer T;
+    };
+} ? T : never;
+type UnwrapRef<T> = T extends ScalarReference<any> ? UnwrapScalarReference<T> : T extends Reference<any> ? UnwrapReference<T> : T;
+type UnwrapScalarReference<T extends ScalarReference<any>> = T extends ScalarReference<infer Value> ? Value : T;
+type UnwrapReference<T extends Reference<any>> = T extends Reference<infer Value> ? Value : T;
+type UnwrapCollection<T> = T extends Collection<infer Value> ? Value : T;
+type UnwrapArray<T> = T extends (infer Value)[] ? Value : T;
+type ValueOf<T extends Dictionary> = T[keyof T];
+export type InferEntity<Schema> = Schema extends EntitySchema<infer Entity, any> ? Entity : never;
+export {};

package/entity/defineEntity.js

@@ -0,0 +1,684 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineEntity = defineEntity;
+const types_1 = require("../types");
+const EntitySchema_1 = require("../metadata/EntitySchema");
+class PropertyOptionsBuilder {
+    '~options';
+    '~type';
+    constructor(options) {
+        this['~options'] = options;
+    }
+    /**
+     * Alias for `fieldName`.
+     */
+    name(name) {
+        return new PropertyOptionsBuilder({ ...this['~options'], name });
+    }
+    /**
+     * Specify database column name for this property.
+     *
+     * @see https://mikro-orm.io/docs/naming-strategy
+     */
+    fieldName(fieldName) {
+        return new PropertyOptionsBuilder({ ...this['~options'], fieldName });
+    }
+    /**
+     * Specify database column names for this property.
+     * Same as `fieldName` but for composite FKs.
+     *
+     * @see https://mikro-orm.io/docs/naming-strategy
+     */
+    fieldNames(...fieldNames) {
+        return new PropertyOptionsBuilder({ ...this['~options'], fieldNames });
+    }
+    /**
+     * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is only for simple properties represented by a single column. (SQL only)
+     */
+    columnType(columnType) {
+        return new PropertyOptionsBuilder({ ...this['~options'], columnType });
+    }
+    /**
+     * Specify an exact database column type for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. This option is suitable for composite keys, where one property is represented by multiple columns. (SQL only)
+     */
+    columnTypes(...columnTypes) {
+        return new PropertyOptionsBuilder({ ...this['~options'], columnTypes });
+    }
+    /**
+     * Explicitly specify the runtime type.
+     *
+     * @see https://mikro-orm.io/docs/metadata-providers
+     * @see https://mikro-orm.io/docs/custom-types
+     */
+    type(type) {
+        return new PropertyOptionsBuilder({ ...this['~options'], type });
+    }
+    /**
+     * Runtime type of the property. This is the JS type that your property is mapped to, e.g. `string` or `number`, and is normally inferred automatically via `reflect-metadata`.
+     * In some cases, the inference won't work, and you might need to specify the `runtimeType` explicitly - the most common one is when you use a union type with null like `foo: number | null`.
+     */
+    runtimeType(runtimeType) {
+        return new PropertyOptionsBuilder({ ...this['~options'], runtimeType });
+    }
+    /**
+     * Set length of database column, used for datetime/timestamp/varchar column types for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    length(length) {
+        return new PropertyOptionsBuilder({ ...this['~options'], length });
+    }
+    /**
+     * Set precision of database column to represent the number of significant digits. (SQL only)
+     */
+    precision(precision) {
+        return new PropertyOptionsBuilder({ ...this['~options'], precision });
+    }
+    /**
+     * Set scale of database column to represents the number of digits after the decimal point. (SQL only)
+     */
+    scale(scale) {
+        return new PropertyOptionsBuilder({ ...this['~options'], scale });
+    }
+    /**
+     * Explicitly specify the auto increment of the primary key.
+     */
+    autoincrement(autoincrement = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], autoincrement });
+    }
+    /**
+     * Add the property to the `returning` statement.
+     */
+    returning(returning = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], returning });
+    }
+    /**
+     * Automatically set the property value when entity gets created, executed during flush operation.
+     * @param entity
+     */
+    onCreate(onCreate) {
+        return new PropertyOptionsBuilder({ ...this['~options'], onCreate });
+    }
+    /**
+     * Automatically update the property value every time entity gets updated, executed during flush operation.
+     * @param entity
+     */
+    onUpdate(onUpdate) {
+        return new PropertyOptionsBuilder({ ...this['~options'], onUpdate });
+    }
+    /**
+     * Specify default column value for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
+     * This is a runtime value, assignable to the entity property. (SQL only)
+     */
+    default(defaultValue) {
+        return new PropertyOptionsBuilder({ ...this['~options'], default: defaultValue });
+    }
+    /**
+     * Specify SQL functions for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     * Since v4 you should use defaultRaw for SQL functions. e.g. now()
+     */
+    defaultRaw(defaultRaw) {
+        return new PropertyOptionsBuilder({ ...this['~options'], defaultRaw });
+    }
+    /**
+     * Set to map some SQL snippet for the entity.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#formulas Formulas
+     */
+    formula(formula) {
+        return new PropertyOptionsBuilder({ ...this['~options'], formula });
+    }
+    /**
+     * For generated columns. This will be appended to the column type after the `generated always` clause.
+     */
+    generated(generated) {
+        return new PropertyOptionsBuilder({ ...this['~options'], generated });
+    }
+    /**
+     * Set column as nullable for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}.
+     */
+    nullable(nullable = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], nullable });
+    }
+    /**
+     * Set column as unsigned for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    unsigned(unsigned = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], unsigned });
+    }
+    /**
+     * Set false to define {@link https://mikro-orm.io/docs/serializing#shadow-properties Shadow Property}.
+     */
+    persist(persist = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], persist });
+    }
+    /**
+     * Set false to disable hydration of this property. Useful for persisted getters.
+     */
+    hydrate(hydrate = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], hydrate });
+    }
+    /**
+     * 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 new PropertyOptionsBuilder({ ...this['~options'], ref });
+    }
+    /**
+     * Set false to disable change tracking on a property level.
+     *
+     * @see https://mikro-orm.io/docs/unit-of-work#change-tracking-and-performance-considerations
+     */
+    trackChanges(trackChanges = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], trackChanges });
+    }
+    /**
+     * Set to true to omit the property when {@link https://mikro-orm.io/docs/serializing Serializing}.
+     */
+    hidden(hidden = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], hidden });
+    }
+    /**
+     * 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 new PropertyOptionsBuilder({ ...this['~options'], version });
+    }
+    /**
+     * Set to true to enable {@link https://mikro-orm.io/docs/transactions#optimistic-locking Optimistic Locking} via concurrency fields.
+     */
+    concurrencyCheck(concurrencyCheck = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], concurrencyCheck });
+    }
+    /**
+     * Explicitly specify index on a property.
+     */
+    index(index = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], index });
+    }
+    /**
+     * Set column as unique for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    unique(unique = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], unique });
+    }
+    /**
+     * Specify column with check constraints. (Postgres driver only)
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#check-constraints
+     */
+    check(check) {
+        return new PropertyOptionsBuilder({ ...this['~options'], check });
+    }
+    /**
+     * Set to omit the property from the select clause for lazy loading.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#lazy-scalar-properties
+     */
+    lazy(lazy = true, ref = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], lazy, ref });
+    }
+    /**
+     * Set true to define entity's unique primary key identifier.
+     *
+     * @see https://mikro-orm.io/docs/decorators#primarykey
+     */
+    primary(primary = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], primary });
+    }
+    /**
+     * Set true to define the properties as setter. (virtual)
+     *
+     * @example
+     * ```
+     * @Property({ setter: true })
+     * set address(value: string) {
+     *     this._address = value.toLocaleLowerCase();
+     * }
+     * ```
+     */
+    setter(setter = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], setter });
+    }
+    /**
+     * Set true to define the properties as getter. (virtual)
+     *
+     * @example
+     * ```
+     * @Property({ getter: true })
+     * get fullName() {
+     *   return this.firstName + this.lastName;
+     * }
+     * ```
+     */
+    getter(getter = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], getter });
+    }
+    /**
+     * When defining a property over a method (not a getter, a regular function), you can use this option to point
+     * to the method name.
+     *
+     * @example
+     * ```
+     * @Property({ getter: true })
+     * getFullName() {
+     *   return this.firstName + this.lastName;
+     * }
+     * ```
+     */
+    getterName(getterName) {
+        return new PropertyOptionsBuilder({ ...this['~options'], getterName });
+    }
+    /**
+     * Set to define serialized primary key for MongoDB. (virtual)
+     * Alias for `@SerializedPrimaryKey()` decorator.
+     *
+     * @see https://mikro-orm.io/docs/decorators#serializedprimarykey
+     */
+    serializedPrimaryKey(serializedPrimaryKey = true) {
+        return new PropertyOptionsBuilder({ ...this['~options'], serializedPrimaryKey });
+    }
+    /**
+     * Set to use serialize property. Allow to specify a callback that will be used when serializing a property.
+     *
+     * @see https://mikro-orm.io/docs/serializing#property-serializers
+     */
+    serializer(serializer) {
+        return new PropertyOptionsBuilder({ ...this['~options'], serializer });
+    }
+    /**
+     * Specify name of key for the serialized value.
+     */
+    serializedName(serializedName) {
+        return new PropertyOptionsBuilder({ ...this['~options'], serializedName });
+    }
+    /**
+     * Specify serialization groups for `serialize()` calls. If a property does not specify any group, it will be included,
+     * otherwise only properties with a matching group are included.
+     */
+    groups(...groups) {
+        return new PropertyOptionsBuilder({ ...this['~options'], groups });
+    }
+    /**
+     * Specify a custom order based on the values. (SQL only)
+     */
+    customOrder(...customOrder) {
+        return new PropertyOptionsBuilder({ ...this['~options'], customOrder });
+    }
+    /**
+     * Specify comment of column for {@link https://mikro-orm.io/docs/schema-generator Schema Generator}. (SQL only)
+     */
+    comment(comment) {
+        return new PropertyOptionsBuilder({ ...this['~options'], comment });
+    }
+    /** mysql only */
+    extra(extra) {
+        return new PropertyOptionsBuilder({ ...this['~options'], extra });
+    }
+    /**
+     * Set to avoid a perpetual diff from the {@link https://mikro-orm.io/docs/schema-generator Schema Generator} when columns are generated.
+     *
+     * @see https://mikro-orm.io/docs/defining-entities#sql-generated-columns
+     */
+    ignoreSchemaChanges(...ignoreSchemaChanges) {
+        return new PropertyOptionsBuilder({ ...this['~options'], ignoreSchemaChanges });
+    }
+    $type() {
+        return new PropertyOptionsBuilder({ ...this['~options'] });
+    }
+}
+class EnumOptionsBuilder extends PropertyOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    array(array = true) {
+        return new EnumOptionsBuilder({ ...this['~options'], array });
+    }
+    /** for postgres, by default it uses text column with check constraint */
+    nativeEnumName(nativeEnumName) {
+        return new EnumOptionsBuilder({ ...this['~options'], nativeEnumName });
+    }
+}
+class EmbeddedOptionsBuilder extends PropertyOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    prefix(prefix) {
+        return new EmbeddedOptionsBuilder({ ...this['~options'], prefix });
+    }
+    prefixMode(prefixMode) {
+        return new EmbeddedOptionsBuilder({ ...this['~options'], prefixMode });
+    }
+    object(object = true) {
+        return new EmbeddedOptionsBuilder({ ...this['~options'], object });
+    }
+    array(array = true) {
+        return new EmbeddedOptionsBuilder({ ...this['~options'], array });
+    }
+}
+class ReferenceOptionsBuilder extends PropertyOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    /** Set what actions on owning entity should be cascaded to the relationship. Defaults to [Cascade.PERSIST, Cascade.MERGE] (see {@doclink cascading}). */
+    cascade(...cascade) {
+        return new ReferenceOptionsBuilder({ ...this['~options'], cascade });
+    }
+    /** Always load the relationship. Discouraged for use with to-many relations for performance reasons. */
+    eager(eager = true) {
+        return new ReferenceOptionsBuilder({ ...this['~options'], eager });
+    }
+    /** 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) {
+        return new ReferenceOptionsBuilder({ ...this['~options'], strategy });
+    }
+    /**
+     * @internal
+     * re-declare to override type inference
+     */
+    /* istanbul ignore next */
+    ref(ref = true) {
+        return new ReferenceOptionsBuilder({ ...this['~options'], ref });
+    }
+    /**
+     * @internal
+     * re-declare to override type inference
+     */
+    /* istanbul ignore next */
+    primary(primary = true) {
+        return new ReferenceOptionsBuilder({ ...this['~options'], primary });
+    }
+}
+class ManyToManyOptionsBuilder extends ReferenceOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    /** 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 new ManyToManyOptionsBuilder({ ...this['~options'], owner });
+    }
+    /** Point to the inverse side property name. */
+    inversedBy(inversedBy) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], inversedBy });
+    }
+    /** Point to the owning side property name. */
+    mappedBy(mappedBy) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], mappedBy });
+    }
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
+    where(...where) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], where: where });
+    }
+    /** Set default ordering. */
+    orderBy(...orderBy) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], orderBy });
+    }
+    /** Force stable insertion order of items in the collection (see {@doclink collections | Collections}). */
+    fixedOrder(fixedOrder = true) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], fixedOrder });
+    }
+    /** Override default order column name (`id`) for fixed ordering. */
+    fixedOrderColumn(fixedOrderColumn) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], fixedOrderColumn });
+    }
+    /** Override default name for pivot table (see {@doclink naming-strategy | Naming Strategy}). */
+    pivotTable(pivotTable) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], pivotTable });
+    }
+    /** Set pivot entity for this relation (see {@doclink collections#custom-pivot-table-entity | Custom pivot table entity}). */
+    pivotEntity(pivotEntity) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], pivotEntity });
+    }
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    joinColumn(joinColumn) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], joinColumn });
+    }
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    joinColumns(...joinColumns) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], joinColumns });
+    }
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    inverseJoinColumn(inverseJoinColumn) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], inverseJoinColumn });
+    }
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    inverseJoinColumns(...inverseJoinColumns) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], inverseJoinColumns });
+    }
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    referenceColumnName(referenceColumnName) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], referenceColumnName });
+    }
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames(...referencedColumnNames) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], referencedColumnNames });
+    }
+    /** What to do when the target entity gets deleted. */
+    deleteRule(deleteRule) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], deleteRule });
+    }
+    /** What to do when the reference to the target entity gets updated. */
+    updateRule(updateRule) {
+        return new ManyToManyOptionsBuilder({ ...this['~options'], updateRule });
+    }
+}
+class ManyToOneOptionsBuilder extends ReferenceOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    /** Point to the inverse side property name. */
+    inversedBy(inversedBy) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], inversedBy });
+    }
+    /** Wrap the entity in {@apilink Reference} wrapper. */
+    ref(ref = true) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], ref });
+    }
+    /** Use this relation as a primary key. */
+    primary(primary = true) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], primary });
+    }
+    /** Map this relation to the primary key value instead of an entity. */
+    mapToPk(mapToPk = true) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], mapToPk });
+    }
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    joinColumn(joinColumn) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], joinColumn });
+    }
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    joinColumns(...joinColumns) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], joinColumns });
+    }
+    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
+    ownColumns(...ownColumns) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], ownColumns });
+    }
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    referenceColumnName(referenceColumnName) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], referenceColumnName });
+    }
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames(...referencedColumnNames) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], referencedColumnNames });
+    }
+    /** What to do when the target entity gets deleted. */
+    deleteRule(deleteRule) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], deleteRule });
+    }
+    /** What to do when the reference to the target entity gets updated. */
+    updateRule(updateRule) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], updateRule });
+    }
+    /** 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) {
+        return new ManyToOneOptionsBuilder({ ...this['~options'], deferMode });
+    }
+}
+class OneToManyOptionsBuilder extends ReferenceOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    /** Remove the entity when it gets disconnected from the relationship (see {@doclink cascading | Cascading}). */
+    orphanRemoval(orphanRemoval = true) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], orphanRemoval });
+    }
+    /** Set default ordering. */
+    orderBy(orderBy) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], orderBy });
+    }
+    /** Condition for {@doclink collections#declarative-partial-loading | Declarative partial loading}. */
+    where(where) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], where });
+    }
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    joinColumn(joinColumn) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], joinColumn });
+    }
+    /** Override the default database column name on the owning side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    joinColumns(...joinColumns) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], joinColumns });
+    }
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    inverseJoinColumn(inverseJoinColumn) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], inverseJoinColumn });
+    }
+    /** Override the default database column name on the inverse side (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    inverseJoinColumns(...inverseJoinColumns) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], inverseJoinColumns });
+    }
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is only for simple properties represented by a single column. */
+    referenceColumnName(referenceColumnName) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], referenceColumnName });
+    }
+    /** Override the default database column name on the target entity (see {@doclink naming-strategy | Naming Strategy}). This option is suitable for composite keys, where one property is represented by multiple columns. */
+    referencedColumnNames(...referencedColumnNames) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], referencedColumnNames });
+    }
+}
+class OneToManyOptionsBuilderOnlyMappedBy {
+    constructor(options) {
+        this['~options'] = options;
+    }
+    /** Point to the owning side property name. */
+    mappedBy(mappedBy) {
+        return new OneToManyOptionsBuilder({ ...this['~options'], mappedBy });
+    }
+}
+class OneToOneOptionsBuilder extends ReferenceOptionsBuilder {
+    constructor(options) {
+        super(options);
+        this['~options'] = options;
+    }
+    /** 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 new OneToOneOptionsBuilder({ ...this['~options'], owner });
+    }
+    /** Point to the inverse side property name. */
+    inversedBy(inversedBy) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], inversedBy });
+    }
+    /** Wrap the entity in {@apilink Reference} wrapper. */
+    ref(ref = true) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], ref });
+    }
+    /** Use this relation as a primary key. */
+    primary(primary = true) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], primary });
+    }
+    /** Map this relation to the primary key value instead of an entity. */
+    mapToPk(mapToPk = true) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], mapToPk });
+    }
+    /** When a part of a composite column is shared in other properties, use this option to specify what columns are considered as owned by this property. This is useful when your composite property is nullable, but parts of it are not. */
+    ownColumns(...ownColumns) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], ownColumns });
+    }
+    /** What to do when the target entity gets deleted. */
+    deleteRule(deleteRule) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], deleteRule });
+    }
+    /** What to do when the reference to the target entity gets updated. */
+    updateRule(updateRule) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], updateRule });
+    }
+    /** 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) {
+        return new OneToOneOptionsBuilder({ ...this['~options'], deferMode });
+    }
+}
+function createPropertyBuilders(options) {
+    return Object.fromEntries(Object.entries(options).map(([key, value]) => [key, () => new PropertyOptionsBuilder({ type: value })]));
+}
+const propertyBuilders = {
+    ...createPropertyBuilders(types_1.types),
+    json: () => new PropertyOptionsBuilder({ type: types_1.types.json }),
+    formula: (formula) => new PropertyOptionsBuilder({ formula }),
+    type: (type) => new PropertyOptionsBuilder({ type }),
+    enum: (items) => new EnumOptionsBuilder({
+        enum: true,
+        items,
+    }),
+    embedded: (target) => new EmbeddedOptionsBuilder({
+        entity: () => target,
+        kind: 'embedded',
+    }),
+    manyToMany: (target) => new ManyToManyOptionsBuilder({
+        entity: () => target,
+        kind: 'm:n',
+    }),
+    manyToOne: (target) => new ManyToOneOptionsBuilder({
+        entity: () => target,
+        kind: 'm:1',
+        ref: true,
+    }),
+    oneToMany: (target) => new OneToManyOptionsBuilderOnlyMappedBy({
+        entity: () => target,
+        kind: '1:m',
+    }),
+    oneToOne: (target) => new OneToOneOptionsBuilder({
+        entity: () => target,
+        kind: '1:1',
+        ref: true,
+    }),
+};
+function getBuilderOptions(builder) {
+    return '~options' in builder ? builder['~options'] : builder;
+}
+function defineEntity(meta) {
+    const { properties: propertiesOrGetter, ...options } = meta;
+    const propertyOptions = typeof propertiesOrGetter === 'function' ? propertiesOrGetter(propertyBuilders) : propertiesOrGetter;
+    const properties = {};
+    for (const [key, builder] of Object.entries(propertyOptions)) {
+        const values = new Map();
+        if (typeof builder === 'function') {
+            Object.defineProperty(properties, key, {
+                get: () => {
+                    let value = values.get(key);
+                    if (value === undefined) {
+                        value = getBuilderOptions(builder());
+                        values.set(key, value);
+                    }
+                    return value;
+                },
+                set: (value) => {
+                    values.set(key, value);
+                },
+                enumerable: true,
+            });
+        }
+        else {
+            Object.defineProperty(properties, key, {
+                value: getBuilderOptions(builder),
+                writable: true,
+                enumerable: true,
+            });
+        }
+    }
+    return new EntitySchema_1.EntitySchema({ properties, ...options });
+}
+defineEntity.properties = propertyBuilders;

package/entity/index.d.ts

@@ -11,3 +11,4 @@ export * from './Reference';
 export * from './BaseEntity';
 export * from './WrappedEntity';
 export * from './wrap';
+export * from './defineEntity';

package/entity/index.js

@@ -27,3 +27,4 @@ __exportStar(require("./Reference"), exports);
 __exportStar(require("./BaseEntity"), exports);
 __exportStar(require("./WrappedEntity"), exports);
 __exportStar(require("./wrap"), exports);
+__exportStar(require("./defineEntity"), exports);

package/hydration/ObjectHydrator.js

@@ -65,7 +65,7 @@ class ObjectHydrator extends Hydrator_1.Hydrator {
             const ret = [];
             const idx = this.tmpIndex++;
             const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
-            if (prop.getter && !prop.setter) {
+            if (prop.getter && !prop.setter && prop.persist === false) {
                 return [];
             }
             if (prop.ref) {

package/index.mjs

@@ -182,6 +182,7 @@ export const compareBuffers = mod.compareBuffers;
 export const compareObjects = mod.compareObjects;
 export const createSqlFunction = mod.createSqlFunction;
 export const defineConfig = mod.defineConfig;
+export const defineEntity = mod.defineEntity;
 export const equals = mod.equals;
 export const getOnConflictFields = mod.getOnConflictFields;
 export const getOnConflictReturningFields = mod.getOnConflictReturningFields;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mikro-orm/core",
-  "version": "6.4.17-dev.24",
+  "version": "6.4.17-dev.26",
   "description": "TypeScript ORM for Node.js based on Data Mapper, Unit of Work and Identity Map patterns. Supports MongoDB, MySQL, PostgreSQL and SQLite databases as well as usage with vanilla JavaScript.",
   "main": "index.js",
   "module": "index.mjs",
@@ -64,7 +64,7 @@
     "esprima": "4.0.1",
     "fs-extra": "11.3.0",
     "globby": "11.1.0",
-    "mikro-orm": "6.4.17-dev.24",
+    "mikro-orm": "6.4.17-dev.26",
     "reflect-metadata": "0.2.2"
   }
 }

package/typings.js

@@ -72,7 +72,7 @@ class EntityMetadata {
             // `prop.userDefined` is either `undefined` or `false`
             const discriminator = this.root.discriminatorColumn === prop.name && prop.userDefined === false;
             // even if we don't have a setter, do not ignore value from database!
-            const onlyGetter = prop.getter && !prop.setter;
+            const onlyGetter = prop.getter && !prop.setter && prop.persist === false;
             return !prop.inherited && prop.hydrate !== false && !discriminator && !prop.embedded && !onlyGetter;
         });
         this.trackingProps = this.hydrateProps