remult 0.22.8 → 0.22.9-exp.0

package/esm/index.d.ts

@@ -1,8 +1,9 @@
-export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, } from './src/remult3/remult3';
-export { Field, Fields, IdEntity, EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
+export { OmitEB, FieldsMetadata, FieldRef, IdFieldRef, FieldsRef, EntityMetadata, EntityOrderBy, EntityFilter, FindOptions, QueryResult, QueryOptions, Repository, FindFirstOptions, ComparisonValueFilter, ValueFilter, IdFilter, ContainsStringValueFilter, EntityRef, SortSegments, Paginator, LiveQuery, LiveQueryChangeInfo, Subscribable, RefSubscriber, RefSubscriberBase, RelationOptions, RelationOptionsBase, ObjectMembersOnly, MembersToInclude, RepositoryRelations, } from './src/remult3/remult3';
+export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListFieldOptions, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';
 export { getEntityRef } from './src/remult3/getEntityRef';
-export { StringFieldOptions } from './src/remult3/RepositoryImplementation';
+export { Field, Fields, StringFieldOptions } from './src/remult3/Fields';
+export { IdEntity } from './src/remult3/IdEntity';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { EntityOptions } from './src/entity';
 export { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo, RestDataProviderHttpProvider, } from './src/data-interfaces';

package/esm/index.js

@@ -1,6 +1,8 @@
-export { Field, Fields, IdEntity, EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
+export { EntityBase, ControllerBase, FieldType, getFields, ValueListFieldType, getValueList, ValueListInfo, CaptionTransformer, } from './src/remult3/RepositoryImplementation';
 export { Entity } from './src/remult3/entity';
 export { getEntityRef } from './src/remult3/getEntityRef';
+export { Field, Fields } from './src/remult3/Fields';
+export { IdEntity } from './src/remult3/IdEntity';
 export { describeClass } from './src/remult3/DecoratorReplacer';
 export { RestDataProvider } from './src/data-providers/rest-data-provider'; //V
 export { InMemoryDataProvider } from './src/data-providers/in-memory-database'; //V

package/esm/internals.d.ts

@@ -0,0 +1,6 @@
+export { getRelationInfo } from './src/remult3/relationInfoMember';
+export { decorateColumnSettings } from './src/remult3/RepositoryImplementation';
+export { getEntitySettings } from './src/remult3/getEntityRef';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
+export { actionInfo } from './src/server-action-info';
+export { RelationInfo } from './src/remult3/remult3';

package/esm/internals.js

@@ -0,0 +1,5 @@
+export { getRelationInfo } from './src/remult3/relationInfoMember';
+export { decorateColumnSettings } from './src/remult3/RepositoryImplementation';
+export { getEntitySettings } from './src/remult3/getEntityRef';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
+export { actionInfo } from './src/server-action-info';

package/esm/live-query/data-provider-live-query-storage.js

@@ -1,7 +1,8 @@
 import { __decorate, __metadata } from "tslib";
 import { initDataProvider } from '../server/initDataProvider';
 import { allEntities, Remult } from '../src/context';
-import { EntityBase, Fields } from '../src/remult3/RepositoryImplementation';
+import { EntityBase } from '../src/remult3/RepositoryImplementation';
+import { Fields } from '../src/remult3/Fields';
 import { Entity } from '../src/remult3/entity';
 export class DataProviderLiveQueryStorage {
     repo;

package/esm/server/expressBridge.d.ts

@@ -3,7 +3,7 @@ import type { UserInfo } from '../src/context';
 import { Remult } from '../src/context';
 import type { DataProvider } from '../src/data-interfaces';
 import type { LiveQueryStorage, SubscriptionServer } from '../src/live-query/SubscriptionServer';
-import { IdEntity } from '../src/remult3/RepositoryImplementation';
+import { IdEntity } from '../src/remult3/IdEntity';
 import type { Repository } from '../src/remult3/remult3';
 import type { queuedJobInfoResponse } from '../src/server-action';
 export interface RemultServerOptions<RequestType> {

package/esm/server/expressBridge.js

@@ -4,7 +4,8 @@ import { Remult, RemultAsyncLocalStorage, allEntities } from '../src/context';
 import { DataApi, serializeError } from '../src/data-api';
 import { liveQueryKeepAliveRoute, streamUrl, } from '../src/live-query/SubscriptionChannel';
 import { InMemoryLiveQueryStorage, LiveQueryPublisher, } from '../src/live-query/SubscriptionServer';
-import { Fields, IdEntity } from '../src/remult3/RepositoryImplementation';
+import { IdEntity } from '../src/remult3/IdEntity';
+import { Fields } from '../src/remult3/Fields';
 import { Entity } from '../src/remult3/entity';
 import { getEntityKey } from '../src/remult3/getEntityRef';
 import { Action, classBackendMethodsArray } from '../src/server-action';

package/esm/src/column.d.ts

@@ -3,7 +3,7 @@ import type { RepositoryImplementation } from './remult3/RepositoryImplementatio
 export declare function makeTitle(name: string): string;
 export declare class LookupColumn<T> {
     private repository;
-    id: idType<T>;
+    private isManyToOneRelation;
     toJson(): any;
     setId(val: any): void;
     waitLoadOf(id: any): Promise<T>;
@@ -12,7 +12,8 @@ export declare class LookupColumn<T> {
         item: T;
     };
     set(item: T): void;
-    constructor(repository: RepositoryImplementation<T>, id: idType<T>);
+    id: idType<T>;
+    constructor(repository: RepositoryImplementation<T>, isManyToOneRelation: any);
     get item(): T;
     waitLoad(): Promise<T>;
 }

package/esm/src/column.js

@@ -12,7 +12,7 @@ export function makeTitle(name) {
 }
 export class LookupColumn {
     repository;
-    id;
+    isManyToOneRelation;
     toJson() {
         if (!this.storedItem)
             return undefined;
@@ -28,12 +28,12 @@ export class LookupColumn {
     waitLoadOf(id) {
         if (id === undefined || id === null)
             return null;
-        return this.repository.getCachedByIdAsync(id);
+        return this.repository.getCachedByIdAsync(id, false);
     }
     get(id) {
         if (id === undefined || id === null)
             return null;
-        return this.repository.getCachedById(id);
+        return this.repository.getCachedById(id, this.isManyToOneRelation);
     }
     storedItem;
     set(item) {
@@ -60,9 +60,10 @@ export class LookupColumn {
             this.id = undefined;
         }
     }
-    constructor(repository, id) {
+    id;
+    constructor(repository, isManyToOneRelation) {
         this.repository = repository;
-        this.id = id;
+        this.isManyToOneRelation = isManyToOneRelation;
     }
     get item() {
         if (this.storedItem)

package/esm/src/context.js

@@ -2,7 +2,7 @@ import { RestDataProvider } from './data-providers/rest-data-provider';
 import { LiveQueryClient } from './live-query/LiveQueryClient';
 import { SseSubscriptionClient } from './live-query/SseSubscriptionClient';
 import { RemultProxy, remult } from './remult-proxy';
-import { RepositoryImplementation } from './remult3/RepositoryImplementation';
+import { RepositoryImplementation, createOldEntity, } from './remult3/RepositoryImplementation';
 import { actionInfo, serverActionField } from './server-action-info';
 import { buildRestDataProvider, isExternalHttpProvider, } from './buildRestDataProvider';
 export class RemultAsyncLocalStorage {
@@ -57,7 +57,7 @@ export class Remult {
             this.repCache.set(dataProvider, (dpCache = new Map()));
         let r = dpCache.get(entity);
         if (!r) {
-            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider)));
+            dpCache.set(entity, (r = new RepositoryImplementation(entity, this, dataProvider, createOldEntity(entity, this))));
         }
         return r;
     }

package/esm/src/data-providers/array-entity-data-provider.d.ts

@@ -1,4 +1,5 @@
 import type { EntityDataProvider, EntityDataProviderFindOptions } from '../data-interfaces';
+import { type EntityDbNamesBase } from '../filter/filter-consumer-bridge-to-sql-request';
 import { Filter } from '../filter/filter-interfaces';
 import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
 export declare class ArrayEntityDataProvider implements EntityDataProvider {
@@ -6,11 +7,13 @@ export declare class ArrayEntityDataProvider implements EntityDataProvider {
     private rows?;
     static rawFilter(filter: CustomArrayFilter): EntityFilter<any>;
     constructor(entity: EntityMetadata, rows?: any[]);
+    __names: EntityDbNamesBase;
+    init(): Promise<EntityDbNamesBase>;
     private verifyThatRowHasAllNotNullColumns;
     count(where?: Filter): Promise<number>;
     find(options?: EntityDataProviderFindOptions): Promise<any[]>;
-    translateFromJson(row: any): {};
-    translateToJson(row: any): {};
+    translateFromJson(row: any, dbNames: EntityDbNamesBase): {};
+    translateToJson(row: any, dbNames: EntityDbNamesBase): {};
     private idMatches;
     update(id: any, data: any): Promise<any>;
     delete(id: any): Promise<void>;

package/esm/src/data-providers/array-entity-data-provider.js

@@ -1,4 +1,5 @@
 import { CompoundIdField } from '../CompoundIdField';
+import { dbNamesOf, isDbReadonly, } from '../filter/filter-consumer-bridge-to-sql-request';
 import { Filter, customDatabaseFilterToken } from '../filter/filter-interfaces';
 export class ArrayEntityDataProvider {
     entity;
@@ -16,16 +17,24 @@ export class ArrayEntityDataProvider {
         if (!rows)
             rows = [];
         else {
-            for (const r of rows) {
-                this.verifyThatRowHasAllNotNullColumns(r);
-            }
         }
     }
-    verifyThatRowHasAllNotNullColumns(r) {
+    __names;
+    async init() {
+        if (this.__names)
+            return this.__names;
+        this.__names = await dbNamesOf(this.entity);
+        for (const r of this.rows) {
+            this.verifyThatRowHasAllNotNullColumns(r, this.__names);
+        }
+        return this.__names;
+    }
+    verifyThatRowHasAllNotNullColumns(r, names) {
         for (const f of this.entity.fields) {
+            const key = names.$dbNameOf(f);
             if (!f.isServerExpression)
                 if (!f.allowNull) {
-                    if (r[f.key] === undefined || r[f.key] === null) {
+                    if (r[key] === undefined || r[key] === null) {
                         let val = undefined;
                         if (f.valueType === Boolean)
                             val = false;
@@ -33,22 +42,23 @@ export class ArrayEntityDataProvider {
                             val = 0;
                         else if (f.valueType === String)
                             val = '';
-                        r[f.key] = val;
+                        r[key] = val;
                     }
                 }
-                else if (r[f.key] === undefined)
-                    r[f.key] = null;
+                else if (r[key] === undefined)
+                    r[key] = null;
         }
     }
     async count(where) {
         let rows = this.rows;
+        const names = await this.init();
         let j = 0;
         for (let i = 0; i < rows.length; i++) {
             if (!where) {
                 j++;
             }
             else {
-                let x = new FilterConsumerBridgeToObject(rows[i]);
+                let x = new FilterConsumerBridgeToObject(rows[i], names);
                 where.__applyToConsumer(x);
                 if (x.ok)
                     j++;
@@ -58,70 +68,74 @@ export class ArrayEntityDataProvider {
     }
     async find(options) {
         let rows = this.rows;
+        const dbNames = await this.init();
         if (options) {
             if (options.where) {
                 rows = rows.filter((i) => {
-                    let x = new FilterConsumerBridgeToObject(i);
+                    let x = new FilterConsumerBridgeToObject(i, dbNames);
                     options.where.__applyToConsumer(x);
                     return x.ok;
                 });
             }
             if (options.orderBy) {
                 rows = rows.sort((a, b) => {
-                    return options.orderBy.compare(a, b);
+                    return options.orderBy.compare(a, b, dbNames.$dbNameOf);
                 });
             }
             rows = pageArray(rows, options);
         }
         if (rows)
             return rows.map((i) => {
-                return this.translateFromJson(i);
+                return this.translateFromJson(i, dbNames);
             });
     }
-    translateFromJson(row) {
+    translateFromJson(row, dbNames) {
         let result = {};
         for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.fromJson(row[col.key]);
+            result[col.key] = col.valueConverter.fromJson(row[dbNames.$dbNameOf(col)]);
         }
         return result;
     }
-    translateToJson(row) {
+    translateToJson(row, dbNames) {
         let result = {};
         for (const col of this.entity.fields) {
-            result[col.key] = col.valueConverter.toJson(row[col.key]);
+            if (!isDbReadonly(col, dbNames))
+                result[dbNames.$dbNameOf(col)] = col.valueConverter.toJson(row[col.key]);
         }
         return result;
     }
-    idMatches(id) {
+    idMatches(id, names) {
         return (item) => {
-            let x = new FilterConsumerBridgeToObject(item);
+            let x = new FilterConsumerBridgeToObject(item, names);
             Filter.fromEntityFilter(this.entity, this.entity.idMetadata.getIdFilter(id)).__applyToConsumer(x);
             return x.ok;
         };
     }
-    update(id, data) {
-        let idMatches = this.idMatches(id);
+    async update(id, data) {
+        const names = await this.init();
+        let idMatches = this.idMatches(id, names);
         let keys = Object.keys(data);
         for (let i = 0; i < this.rows.length; i++) {
             let r = this.rows[i];
             if (idMatches(r)) {
                 let newR = { ...r };
                 for (const f of this.entity.fields) {
-                    if (!f.dbReadOnly && !f.isServerExpression) {
+                    if (!isDbReadonly(f, names)) {
                         if (keys.includes(f.key)) {
-                            newR[f.key] = f.valueConverter.toJson(data[f.key]);
+                            newR[names.$dbNameOf(f)] = f.valueConverter.toJson(data[f.key]);
                         }
                     }
                 }
-                this.verifyThatRowHasAllNotNullColumns(newR);
+                this.verifyThatRowHasAllNotNullColumns(newR, names);
                 this.rows[i] = newR;
-                return Promise.resolve(this.translateFromJson(this.rows[i]));
+                return Promise.resolve(this.translateFromJson(this.rows[i], names));
             }
         }
         throw new Error("couldn't find id to update: " + id);
     }
-    delete(id) {
-        let idMatches = this.idMatches(id);
+    async delete(id) {
+        const names = await this.init();
+        let idMatches = this.idMatches(id, names);
         for (let i = 0; i < this.rows.length; i++) {
             if (idMatches(this.rows[i])) {
                 this.rows.splice(i, 1);
@@ -131,25 +145,26 @@ export class ArrayEntityDataProvider {
         throw new Error("couldn't find id to delete: " + id);
     }
     async insert(data) {
+        const names = await this.init();
+        let j = this.translateToJson(data, names);
         let idf = this.entity.idMetadata.field;
         if (!(idf instanceof CompoundIdField)) {
             if (idf.options.valueConverter?.fieldTypeInDb === 'autoincrement') {
-                data[idf.key] = 1;
+                j[idf.key] = 1;
                 for (const row of this.rows) {
-                    if (row[idf.key] >= data[idf.key])
-                        data[idf.key] = row[idf.key] + 1;
+                    if (row[idf.key] >= j[idf.key])
+                        j[idf.key] = row[idf.key] + 1;
                 }
             }
-            if (data[idf.key])
+            if (j[idf.key])
                 this.rows.forEach((i) => {
-                    if (data[idf.key] == i[idf.key])
+                    if (j[idf.key] == i[idf.key])
                         throw Error('id already exists');
                 });
         }
-        let j = this.translateToJson(data);
-        this.verifyThatRowHasAllNotNullColumns(j);
+        this.verifyThatRowHasAllNotNullColumns(j, names);
         this.rows.push(j);
-        return Promise.resolve(this.translateFromJson(j));
+        return Promise.resolve(this.translateFromJson(j, names));
     }
 }
 function pageArray(rows, options) {
@@ -172,9 +187,11 @@ function pageArray(rows, options) {
 }
 class FilterConsumerBridgeToObject {
     row;
+    dbNames;
     ok = true;
-    constructor(row) {
+    constructor(row, dbNames) {
         this.row = row;
+        this.dbNames = dbNames;
     }
     databaseCustom(databaseCustom) {
         if (databaseCustom && databaseCustom.arrayFilter) {
@@ -187,7 +204,7 @@ class FilterConsumerBridgeToObject {
     }
     or(orElements) {
         for (const element of orElements) {
-            let filter = new FilterConsumerBridgeToObject(this.row);
+            let filter = new FilterConsumerBridgeToObject(this.row, this.dbNames);
             element.__applyToConsumer(filter);
             if (filter.ok) {
                 return;
@@ -196,47 +213,47 @@ class FilterConsumerBridgeToObject {
         this.ok = false;
     }
     isNull(col) {
-        if (this.row[col.key] != null)
+        if (this.row[this.dbNames.$dbNameOf(col)] != null)
             this.ok = false;
     }
     isNotNull(col) {
-        if (this.row[col.key] == null)
+        if (this.row[this.dbNames.$dbNameOf(col)] == null)
             this.ok = false;
     }
     isIn(col, val) {
         for (const v of val) {
-            if (this.row[col.key] == col.valueConverter.toJson(v)) {
+            if (this.row[this.dbNames.$dbNameOf(col)] == col.valueConverter.toJson(v)) {
                 return;
             }
         }
         this.ok = false;
     }
     isEqualTo(col, val) {
-        if (this.row[col.key] != col.valueConverter.toJson(val))
+        if (this.row[this.dbNames.$dbNameOf(col)] != col.valueConverter.toJson(val))
             this.ok = false;
     }
     isDifferentFrom(col, val) {
-        if (this.row[col.key] == col.valueConverter.toJson(val))
+        if (this.row[this.dbNames.$dbNameOf(col)] == col.valueConverter.toJson(val))
             this.ok = false;
     }
     isGreaterOrEqualTo(col, val) {
-        if (this.row[col.key] < col.valueConverter.toJson(val))
+        if (this.row[this.dbNames.$dbNameOf(col)] < col.valueConverter.toJson(val))
             this.ok = false;
     }
     isGreaterThan(col, val) {
-        if (this.row[col.key] <= col.valueConverter.toJson(val))
+        if (this.row[this.dbNames.$dbNameOf(col)] <= col.valueConverter.toJson(val))
             this.ok = false;
     }
     isLessOrEqualTo(col, val) {
-        if (this.row[col.key] > col.valueConverter.toJson(val))
+        if (this.row[this.dbNames.$dbNameOf(col)] > col.valueConverter.toJson(val))
             this.ok = false;
     }
     isLessThan(col, val) {
-        if (this.row[col.key] >= col.valueConverter.toJson(val))
+        if (this.row[this.dbNames.$dbNameOf(col)] >= col.valueConverter.toJson(val))
             this.ok = false;
     }
     containsCaseInsensitive(col, val) {
-        let v = this.row[col.key];
+        let v = this.row[this.dbNames.$dbNameOf(col)];
         if (!v) {
             this.ok = false;
             return;

package/esm/src/data-providers/rest-data-provider.d.ts

@@ -1,6 +1,6 @@
 import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
 import { UrlBuilder } from '../../urlBuilder';
-import type { ApiClient } from '../context';
+import { type ApiClient } from '../context';
 import { Filter } from '../filter/filter-interfaces';
 import type { EntityMetadata } from '../remult3/remult3';
 export declare class RestDataProvider implements DataProvider {

package/esm/src/data-providers/rest-data-provider.js

@@ -1,7 +1,9 @@
 import { UrlBuilder } from '../../urlBuilder';
 import { buildRestDataProvider, retry } from '../buildRestDataProvider';
+import { Remult } from '../context';
 import { customUrlToken, Filter } from '../filter/filter-interfaces';
 import { actionInfo } from '../server-action-info';
+import { getRelationInfo } from '../remult3/relationInfoMember';
 export class RestDataProvider {
     apiProvider;
     constructor(apiProvider) {
@@ -24,22 +26,64 @@ export class RestDataProvider {
 }
 //@internal
 export function findOptionsToJson(options, meta) {
-    const r = {
-        ...options,
-        where: Filter.entityFilterToJson(meta, options.where),
-    };
+    if (options.include) {
+        let newInclude = {};
+        for (const key in options.include) {
+            if (Object.prototype.hasOwnProperty.call(options.include, key)) {
+                let element = options.include[key];
+                if (typeof element === 'object') {
+                    const rel = getRelationInfo(meta.fields.find(key).options);
+                    if (rel) {
+                        element = findOptionsToJson(element, new Remult().repo(rel.toType()).metadata);
+                    }
+                }
+                newInclude[key] = element;
+            }
+        }
+        options = { ...options, include: newInclude };
+    }
+    if (options.where)
+        options = {
+            ...options,
+            where: Filter.entityFilterToJson(meta, options.where),
+        };
     if (options.load)
-        r.load = options.load(meta.fields).map((y) => y.key);
-    return r;
+        options = {
+            ...options,
+            load: options.load(meta.fields).map((y) => y.key),
+        };
+    return options;
 }
 //@internal
 export function findOptionsFromJson(json, meta) {
     let r = {};
-    for (const key of ['limit', 'page', 'where', 'orderBy']) {
+    for (const key of [
+        'limit',
+        'page',
+        'where',
+        'orderBy',
+        'include',
+    ]) {
         if (json[key] !== undefined) {
             if (key === 'where') {
                 r[key] = Filter.entityFilterFromJson(meta, json.where);
             }
+            else if (key === 'include') {
+                let newInclude = { ...json[key] };
+                for (const key in newInclude) {
+                    if (Object.prototype.hasOwnProperty.call(newInclude, key)) {
+                        let element = newInclude[key];
+                        if (typeof element === 'object') {
+                            const rel = getRelationInfo(meta.fields.find(key).options);
+                            if (rel) {
+                                element = findOptionsFromJson(element, new Remult().repo(rel.toType()).metadata);
+                            }
+                        }
+                        newInclude[key] = element;
+                    }
+                }
+                r[key] = newInclude;
+            }
             else
                 r[key] = json[key];
         }

package/esm/src/remult3/Fields.d.ts

@@ -0,0 +1,46 @@
+import type { ClassType } from '../../classType';
+import type { FieldOptions } from '../column-interfaces';
+import type { Remult } from '../context';
+import type { FindOptions, RelationOptions, RelationOptionsBase } from './remult3';
+import { type ClassFieldDecoratorContextStub } from './RepositoryImplementation';
+export declare class Fields {
+    /**
+     * Stored as a JSON.stringify - to store as json use Fields.json
+     */
+    static object<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
+    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, valueType | undefined>, c?: any) => void;
+    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
+    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
+    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
+    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
+    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, number | undefined>, c?: any) => void;
+    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
+    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, Date | undefined>, c?: any) => void;
+    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
+    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
+    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, string | undefined>, c?: any) => void;
+    static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, boolean | undefined>, c?: any) => void;
+    static reference<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: RelationOptionsBase<entityType, toEntityType>): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, toEntityType>, c?: any) => void;
+    static many<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: (RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>> & {
+        fromEntityType?: ClassType<entityType>;
+    }) | keyof toEntityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, any>, c?: any) => void;
+    static one<entityType, toEntityType>(entity: ClassType<entityType>, toEntityType: () => ClassType<toEntityType>, options?: RelationOptions<entityType, toEntityType, entityType> | keyof entityType): (target: any, context: string | ClassFieldDecoratorContextStub<entityType, any>, c?: any) => void;
+}
+/**Decorates fields that should be used as fields.
+ * for more info see: [Field Types](https://remult.dev/docs/field-types.html)
+ *
+ * FieldOptions can be set in two ways:
+ * @example
+ * // as an object
+ * @Fields.string({ includeInApi:false })
+ * title='';
+ * @example
+ * // as an arrow function that receives `remult` as a parameter
+ * @Fields.string((options,remult) => options.includeInApi = true)
+ * title='';
+ */
+export declare function Field<entityType = any, valueType = any>(valueType: () => ClassType<valueType>, ...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): (target: any, context: ClassFieldDecoratorContextStub<entityType, valueType | undefined> | string, c?: any) => void;
+export interface StringFieldOptions<entityType = any> extends FieldOptions<entityType, string> {
+    maxLength?: number;
+}
+export declare function checkTarget(target: any): void;