remult 0.24.0 → 0.24.2-exp.0

package/esm/remult-express.d.ts

@@ -1,9 +0,0 @@
-import * as express from 'express';
-import type { RemultServerCore, RemultServerOptions } from './server/expressBridge';
-export declare function remultExpress(options?: RemultServerOptions<express.Request> & {
-    bodyParser?: boolean;
-    bodySizeLimit?: string;
-}): RemultExpressServer;
-export type RemultExpressServer = express.RequestHandler & RemultServerCore<express.Request> & {
-    withRemult: (req: express.Request, res: express.Response, next: VoidFunction) => void;
-};

package/esm/remult-fastify.d.ts

@@ -1,6 +0,0 @@
-import type { FastifyPluginCallback, FastifyRequest } from 'fastify';
-import type { RemultServerCore, RemultServerOptions } from './server/expressBridge';
-export declare function remultFastify(options: RemultServerOptions<FastifyRequest>): RemultFastifyServer;
-export type RemultFastifyServer = FastifyPluginCallback & RemultServerCore<FastifyRequest> & {
-    withRemult<T>(req: FastifyRequest, what: () => Promise<T>): Promise<T>;
-};

package/esm/remult-fresh.d.ts

@@ -1,17 +0,0 @@
-import type { RemultServerCore, RemultServerOptions } from './server/expressBridge';
-export declare function remultFresh(options: RemultServerOptions<FreshRequest>, response: FreshResponse): RemultFresh;
-export interface RemultFresh extends RemultServerCore<FreshRequest> {
-    handle(req: FreshRequest, ctx: FreshContext): Promise<any>;
-}
-export interface FreshRequest {
-    url: string;
-    method: string;
-    json: () => Promise<any>;
-}
-export interface FreshContext {
-    next: () => Promise<any>;
-}
-export interface FreshResponse {
-    new (body?: any | undefined, init?: ResponseInit): any;
-    json(data: unknown, init?: ResponseInit): any;
-}

package/esm/remult-hapi.d.ts

@@ -1,6 +0,0 @@
-import type { Request, Plugin } from '@hapi/hapi';
-import { type RemultServerCore, type RemultServerOptions } from './server';
-export declare function remultHapi(options: RemultServerOptions<Request>): RemultHapiServer;
-export type RemultHapiServer = Plugin<any, any> & RemultServerCore<Request> & {
-    withRemult<T>(req: Request, what: () => Promise<T>): Promise<T>;
-};

package/esm/remult-knex/index.d.ts

@@ -1,30 +0,0 @@
-import type { Knex } from 'knex';
-import type { Remult } from '../src/context';
-import type { FieldMetadata } from '../src/column-interfaces';
-import type { DataProvider, EntityDataProvider } from '../src/data-interfaces';
-import type { EntityFilter, EntityMetadata } from '../src/remult3/remult3';
-import type { RepositoryOverloads } from '../src/remult3/RepositoryImplementation';
-export declare class KnexDataProvider implements DataProvider {
-    knex: Knex;
-    constructor(knex: Knex);
-    static getDb(remult?: Remult): Knex<any, any[]>;
-    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static rawFilter(build: CustomKnexFilterBuilderFunction): EntityFilter<any>;
-    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<(knex: any) => void>;
-    isProxy?: boolean;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-}
-export type CustomKnexFilterBuilderFunction = () => Promise<(builder: Knex.QueryBuilder) => void>;
-export declare class KnexSchemaBuilder {
-    private knex;
-    verifyStructureOfAllEntities(remult?: Remult): Promise<void>;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    createIfNotExist(entity: EntityMetadata): Promise<void>;
-    addColumnIfNotExist<T extends EntityMetadata>(entity: T, c: (e: T) => FieldMetadata): Promise<void>;
-    verifyAllColumns<T extends EntityMetadata>(entity: T): Promise<void>;
-    additionalWhere: string;
-    constructor(knex: Knex);
-}
-export declare function buildColumn(x: FieldMetadata, dbName: string, b: Knex.CreateTableBuilder, supportsJson?: boolean): void;
-export declare function createKnexDataProvider(config: Knex.Config): Promise<KnexDataProvider>;

package/esm/remult-mongo.d.ts

@@ -1,24 +0,0 @@
-import { type ClientSession, type Db, type MongoClient } from 'mongodb';
-import type { DataProvider, EntityDataProvider, EntityFilter, EntityMetadata, Remult } from '.';
-import type { RepositoryOverloads } from './src/remult3/RepositoryImplementation';
-export declare class MongoDataProvider implements DataProvider {
-    private db;
-    private client;
-    constructor(db: Db, client: MongoClient | undefined, options?: {
-        session?: ClientSession;
-        disableTransactions?: boolean;
-    });
-    session?: ClientSession;
-    disableTransactions: boolean;
-    static getDb(remult?: Remult): {
-        db: Db;
-        session: ClientSession;
-    };
-    getEntityDataProvider(entity: EntityMetadata<any>): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static filterToRaw<entityType>(entity: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<{
-        $and: any[];
-    } | {
-        $and?: undefined;
-    }>;
-}

package/esm/remult-next.d.ts

@@ -1,25 +0,0 @@
-/// <reference types="node" />
-import type { GetServerSideProps, NextApiHandler, NextApiRequest, PreviewData } from 'next';
-import type { ParsedUrlQuery } from 'querystring';
-import type { RemultServerCore, RemultServerOptions } from './server';
-export declare function remultNext(options?: RemultServerOptions<NextApiRequest>): RemultNextServer;
-export type RemultNextServer = RemultServerCore<NextApiRequest> & NextApiHandler & {
-    getServerSideProps<P extends {
-        [key: string]: any;
-    } = {
-        [key: string]: any;
-    }, Q extends ParsedUrlQuery = ParsedUrlQuery, D extends PreviewData = PreviewData>(getServerPropsFunction: GetServerSideProps<P, Q, D>): GetServerSideProps<P, Q, D>;
-    /** Creates a `next.js` handler with remult defined in the correct context
-     * @see
-     * https://remult.dev/tutorials/react-next/appendix-1-get-server-side-props.html#using-remult-in-a-next-js-api-handler
-     */
-    handle<T>(handler: NextApiHandler<T>): NextApiHandler<T>;
-};
-export declare function remultNextApp(options?: RemultServerOptions<Request>): RemultNextAppServer;
-export type RemultNextAppServer = RemultServerCore<Request> & {
-    GET: (req: Request) => Promise<Response>;
-    PUT: (req: Request) => Promise<Response>;
-    POST: (req: Request) => Promise<Response>;
-    DELETE: (req: Request) => Promise<Response>;
-    withRemult<T>(what: () => Promise<T>): Promise<T>;
-};

package/esm/remult-sveltekit.d.ts

@@ -1,6 +0,0 @@
-import type { Handle, RequestEvent } from '@sveltejs/kit';
-import type { RemultServerCore, RemultServerOptions } from './server';
-export declare function remultSveltekit(options?: RemultServerOptions<RequestEvent>): RemultSveltekitServer;
-export type RemultSveltekitServer = RemultServerCore<RequestEvent> & Handle & {
-    withRemult<T>(request: RequestEvent, what: () => Promise<T>): Promise<T>;
-};

package/esm/server/JsonEntityFileStorage.d.ts

@@ -1,11 +0,0 @@
-import type { JsonEntityStorage } from '../index';
-import { JsonDataProvider } from '../index';
-export declare class JsonEntityFileStorage implements JsonEntityStorage {
-    private folderPath;
-    getItem(entityDbName: string): string;
-    setItem(entityDbName: string, json: string): void;
-    constructor(folderPath: string);
-}
-export declare class JsonFileDataProvider extends JsonDataProvider {
-    constructor(folderPath: string);
-}

package/esm/server/core.d.ts

@@ -1,4 +0,0 @@
-export { queuedJobInfo, QueueStorage, GenericRequestInfo, GenericRequestHandler, GenericResponse, GenericRouter, createRemultServerCore, RemultServerOptions, SpecificRoute, RemultServer, } from './expressBridge';
-export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
-export { SseSubscriptionServer } from '../SseSubscriptionServer';
-export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';

package/esm/server/expressBridge.d.ts

@@ -1,136 +0,0 @@
-import type { ClassType } from '../classType';
-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/IdEntity';
-import type { Repository } from '../src/remult3/remult3';
-import type { queuedJobInfoResponse } from '../src/server-action';
-export interface RemultServerOptions<RequestType> {
-    /**Entities to use for the api */
-    entities?: ClassType<any>[];
-    /**Controller to use for the api */
-    controllers?: ClassType<any>[];
-    /** Will be called to get the current user based on the current request */
-    getUser?: (request: RequestType) => Promise<UserInfo | undefined>;
-    /** Will be called for each request and can be used for configuration */
-    initRequest?: (request: RequestType, options: InitRequestOptions) => Promise<void>;
-    /** Will be called once the server is loaded and the data provider is ready */
-    initApi?: (remult: Remult) => void | Promise<void>;
-    /** Data Provider to use for the api.
-     *
-     * @see [Connecting to a Database](https://remult.dev/docs/databases.html).
-     */
-    dataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>);
-    /** Will create tables and columns in supporting databases. default: true
-     *
-     * @description
-     * when set to true, it'll create entities that do not exist, and add columns that are missing.
-     */
-    ensureSchema?: boolean;
-    /** The path to use for the api, default:/api
-     *
-     * @description
-     * If you want to use a different api path adjust this field
-     */
-    rootPath?: string;
-    /** The default limit to use for find requests that did not specify a limit */
-    defaultGetLimit?: number;
-    /** When set to true (default) it'll console log each api endpoint that is created */
-    logApiEndPoints?: boolean;
-    /** A subscription server to use for live query and message channels */
-    subscriptionServer?: SubscriptionServer;
-    /** A storage to use to store live queries, relevant mostly for serverless scenarios or larger scales */
-    liveQueryStorage?: LiveQueryStorage;
-    /** Used to store the context relevant info for re running a live query */
-    contextSerializer?: {
-        serialize(remult: Remult): Promise<any>;
-        deserialize(json: any, options: InitRequestOptions): Promise<void>;
-    };
-    /** Storage to use for backend methods that use queue */
-    queueStorage?: QueueStorage;
-}
-export interface InitRequestOptions {
-    liveQueryStorage: LiveQueryStorage;
-    readonly remult: Remult;
-}
-export declare function createRemultServerCore<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions: ServerCoreOptions<RequestType>): RemultServer<RequestType>;
-export type GenericRequestHandler = (req: GenericRequestInfo, res: GenericResponse, next: VoidFunction) => void;
-export interface ServerHandleResponse {
-    data?: any;
-    statusCode: number;
-}
-export interface RemultServer<RequestType> extends RemultServerCore<RequestType> {
-    withRemult(req: RequestType, res: GenericResponse, next: VoidFunction): any;
-    registerRouter(r: GenericRouter): void;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    withRemultPromise<T>(request: RequestType, what: () => Promise<T>): Promise<T>;
-}
-export interface RemultServerCore<RequestType> {
-    getRemult(req: RequestType): Promise<Remult>;
-    openApiDoc(options: {
-        title: string;
-        version?: string;
-    }): any;
-}
-export type GenericRouter = {
-    route(path: string): SpecificRoute;
-};
-export type SpecificRoute = {
-    get(handler: GenericRequestHandler): SpecificRoute;
-    put(handler: GenericRequestHandler): SpecificRoute;
-    post(handler: GenericRequestHandler): SpecificRoute;
-    delete(handler: GenericRequestHandler): SpecificRoute;
-};
-export interface GenericRequestInfo {
-    url?: string;
-    method?: any;
-    query?: any;
-    params?: any;
-}
-export interface GenericResponse {
-    json(data: any): any;
-    status(statusCode: number): GenericResponse;
-    end(): any;
-}
-export interface queuedJobInfo {
-    info: queuedJobInfoResponse;
-    userId: string;
-    setErrorResult(error: any): void;
-    setResult(result: any): void;
-    setProgress(progress: number): void;
-}
-export interface QueueStorage {
-    createJob(url: string, userId: string): Promise<string>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
-}
-export declare class EntityQueueStorage implements QueueStorage {
-    private repo;
-    constructor(repo: Repository<JobsInQueueEntity>);
-    sync: Promise<any>;
-    doSync<T>(what: () => Promise<T>): Promise<any>;
-    getJobInfo(queuedJobId: string): Promise<queuedJobInfo>;
-    createJob(url: string, userId: string): Promise<string>;
-}
-export declare class RouteImplementation<RequestType> {
-    private coreOptions;
-    constructor(coreOptions: ServerCoreOptions<RequestType>);
-    map: Map<string, Map<string, GenericRequestHandler>>;
-    route(path: string): SpecificRoute;
-    handle(req: RequestType, gRes?: GenericResponse): Promise<ServerHandleResponse | undefined>;
-    middleware(origReq: RequestType, res: GenericResponse, next: VoidFunction): void;
-}
-export declare class JobsInQueueEntity extends IdEntity {
-    userId: string;
-    url: string;
-    submitTime: Date;
-    doneTime: Date;
-    result: string;
-    done: boolean;
-    error: boolean;
-    progress: number;
-}
-export interface ServerCoreOptions<RequestType> {
-    buildGenericRequestInfo(req: RequestType): GenericRequestInfo;
-    getRequestBody(req: RequestType): Promise<any>;
-}

package/esm/server/index.d.ts

@@ -1,6 +0,0 @@
-import type { RemultServer, RemultServerOptions, ServerCoreOptions } from './expressBridge';
-export { SseSubscriptionServer } from '../SseSubscriptionServer';
-export { DataProviderLiveQueryStorage } from '../live-query/data-provider-live-query-storage';
-export { JsonEntityFileStorage, JsonFileDataProvider, } from './JsonEntityFileStorage';
-export { GenericRequestHandler, GenericRequestInfo, GenericResponse, GenericRouter, InitRequestOptions, QueueStorage, RemultServer, RemultServerCore, RemultServerOptions, SpecificRoute, queuedJobInfo, } from './expressBridge';
-export declare function createRemultServer<RequestType>(options: RemultServerOptions<RequestType>, serverCoreOptions?: ServerCoreOptions<RequestType>): RemultServer<RequestType>;

package/esm/server/initAsyncHooks.d.ts

@@ -1 +0,0 @@
-export declare function initAsyncHooks(): void;

package/esm/server/initDataProvider.d.ts

@@ -1,2 +0,0 @@
-import type { DataProvider } from '../src/data-interfaces';
-export declare function initDataProvider(optionsDataProvider?: DataProvider | Promise<DataProvider> | (() => Promise<DataProvider | undefined>)): Promise<DataProvider>;

package/esm/src/CompoundIdField.d.ts

@@ -1,27 +0,0 @@
-import type { ClassType } from '../classType';
-import type { FieldMetadata, FieldOptions, ValueConverter } from './column-interfaces';
-import type { EntityFilter } from './remult3/remult3';
-export declare class CompoundIdField implements FieldMetadata<string> {
-    fields: FieldMetadata[];
-    constructor(...columns: FieldMetadata[]);
-    apiUpdateAllowed(item: any): boolean;
-    displayValue(item: any): string;
-    includedInApi(item: any): boolean;
-    toInput(value: string, inputType?: string): string;
-    fromInput(inputValue: string, inputType?: string): string;
-    getDbName(): Promise<string>;
-    getId(instance: any): string;
-    options: FieldOptions<any, any>;
-    get valueConverter(): Required<ValueConverter<string>>;
-    target: ClassType<any>;
-    readonly: true;
-    allowNull: boolean;
-    dbReadOnly: boolean;
-    isServerExpression: boolean;
-    key: string;
-    caption: string;
-    inputType: string;
-    dbName: string;
-    valueType: any;
-    isEqualTo(value: FieldMetadata<string> | string): EntityFilter<any>;
-}

package/esm/src/__EntityValueProvider.d.ts

@@ -1,11 +0,0 @@
-export interface packedRowInfo {
-    data: any;
-    isNewRow: boolean;
-    id: string;
-    wasChanged: boolean;
-}
-export interface entityEventListener<entityType> {
-    deleted?: (entity: entityType) => void;
-    saved?: (entity: entityType, isNew: boolean) => void;
-    validating?: (entity: entityType) => Promise<any> | any;
-}

package/esm/src/__RowsOfDataForTesting.d.ts

@@ -1,3 +0,0 @@
-export interface __RowsOfDataForTesting {
-    rows: any;
-}

package/esm/src/buildRestDataProvider.d.ts

@@ -1,30 +0,0 @@
-import type { RestDataProviderHttpProvider } from './data-interfaces';
-export declare function buildRestDataProvider(provider: ExternalHttpProvider | typeof fetch): RestDataProviderHttpProvider;
-export declare function isExternalHttpProvider(item: any): boolean;
-export declare class HttpProviderBridgeToRestDataProviderHttpProvider implements RestDataProviderHttpProvider {
-    private http;
-    constructor(http: ExternalHttpProvider);
-    post(url: string, data: any): Promise<any>;
-    delete(url: string): Promise<void>;
-    put(url: string, data: any): Promise<any>;
-    get(url: string): Promise<any>;
-}
-export declare function retry<T>(what: () => Promise<T>): Promise<T>;
-export declare function toPromise<T>(p: Promise<T> | {
-    toPromise(): Promise<T>;
-}): Promise<any>;
-export declare function processHttpException(ex: any): Promise<any>;
-export interface ExternalHttpProvider {
-    post(url: string, data: any): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-    delete(url: string): Promise<void> | {
-        toPromise(): Promise<void>;
-    };
-    put(url: string, data: any): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-    get(url: string): Promise<any> | {
-        toPromise(): Promise<any>;
-    };
-}

package/esm/src/column-interfaces.d.ts

@@ -1,172 +0,0 @@
-import type { ClassType } from '../classType';
-import type { AllowedForInstance } from './context';
-import type { EntityMetadata, FieldRef, LifecycleEvent } from './remult3/remult3';
-export interface FieldOptions<entityType = any, valueType = any> {
-    /** A human readable name for the field. Can be used to achieve a consistent caption for a field throughout the app
-     * @example
-     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
-     */
-    caption?: string;
-    /** If it can store null in the database */
-    allowNull?: boolean;
-    /** If this field data is included in the api.
-     * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    includeInApi?: AllowedForInstance<entityType>;
-    /** If this field data can be updated in the api.
-     * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    allowApiUpdate?: AllowedForInstance<entityType>;
-    /** An arrow function that'll be used to perform validations on it
-     * @example
-     * @Fields.string({
-     *   validate: Validators.required
-     * })
-     * @example
-     * @Fields.string<Task>({
-     *    validate: task=>{
-     *      if (task.title.length<3)
-     *          throw "Too Short";
-     *   }
-     * })
-     * @example
-     * @Fields.string({
-     *    validate: (_, fieldRef)=>{
-     *      if (fieldRef.value.length<3)
-     *          fieldRef.error = "Too Short";
-     *   }
-     * })
-     */
-    validate?: ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>) | ((entity: entityType, fieldRef: FieldRef<entityType, valueType>) => any | Promise<any>)[];
-    /** Will be fired before this field is saved to the server/database */
-    saving?: (entity: entityType, fieldRef: FieldRef<entityType, valueType>, e: LifecycleEvent<entityType>) => any | Promise<any>;
-    /**  An expression that will determine this fields value on the backend and be provided to the front end*/
-    serverExpression?: (entity: entityType) => valueType | Promise<valueType>;
-    /** The name of the column in the database that holds the data for this field. If no name is set, the key will be used instead.
-     * Be aware that if you are using postgres and want to keep your casing, you have to escape your string with double quotes.
-     * @example
-     *
-     * @Fields.string({ dbName: '"userName"'})
-     * userName=''
-     */
-    dbName?: string;
-    /** Used or fields that are based on an sql expressions, instead of a physical table column
-     * @example
-     *
-     * @Fields.integer({
-     *   sqlExpression:e=> 'length(title)'
-     * })
-     * titleLength = 0;
-     * @Fields.string()
-     * title='';
-     */
-    sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
-    /** For fields that shouldn't be part of an update or insert statement */
-    dbReadOnly?: boolean;
-    /** The value converter to be used when loading and saving this field */
-    valueConverter?: ValueConverter<valueType>;
-    /** an arrow function that translates the value to a display value */
-    displayValue?: (entity: entityType, value: valueType) => string;
-    /** an arrow function that determines the default value of the field, when the entity is created using the `repo.create` method */
-    defaultValue?: (entity: entityType) => valueType | Promise<valueType>;
-    /** The html input type for this field */
-    inputType?: string;
-    /**
-     * @deprecated The 'lazy' option is deprecated and will be removed in future versions.
-     * Use 'Relations.toOne' instead.
-     *
-     * Example usage:
-     * ```
-     * // Deprecated usage with 'lazy' option
-     * @Field(() => Customer, { lazy: true })
-     * customer?: Customer;
-     *
-     * // Preferred usage with 'Relations.toOne'
-     * @Relations.toOne(() => Customer)
-     * customer?: Customer;
-     * ```
-     */
-    lazy?: boolean;
-    /** The value type for this field */
-    valueType?: any;
-    /** The entity type to which this field belongs */
-    target?: ClassType<entityType>;
-    /** The key to be used for this field */
-    key?: string;
-}
-/**Metadata for a `Field`, this metadata can be used in the user interface to provide a richer UI experience */
-export interface FieldMetadata<valueType = any, entityType = any> {
-    /** The field's member name in an object.
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * console.log(taskRepo.metadata.fields.title.key);
-     * // result: title
-     */
-    readonly key: string;
-    /** A human readable caption for the field. Can be used to achieve a consistent caption for a field throughout the app
-     * @example
-     * <input placeholder={taskRepo.metadata.fields.title.caption}/>
-     */
-    readonly caption: string;
-    /** The field's value type (number,string etc...) */
-    readonly valueType: any;
-    /** The options sent to this field's decorator */
-    readonly options: FieldOptions;
-    /** The `inputType` relevant for this field, determined by the options sent to it's decorator and the valueConverter in these options */
-    readonly inputType: string;
-    /** if null is allowed for this field */
-    readonly allowNull: boolean;
-    /** The class that contains this field
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * Task == taskRepo.metadata.fields.title.target //will return true
-     */
-    readonly target: ClassType<valueType>;
-    /** Returns the dbName - based on it's `dbName` option and it's `sqlExpression` option */
-    getDbName(): Promise<string>;
-    /** Indicates if this field is based on a server express */
-    readonly isServerExpression: boolean;
-    /** indicates that this field should only be included in select statement, and excluded from update or insert. useful for db generated ids etc... */
-    readonly dbReadOnly: boolean;
-    /** the Value converter for this field */
-    readonly valueConverter: Required<ValueConverter<valueType>>;
-    /** Get the display value for a specific item
-     * @example
-     * repo.fields.createDate.displayValue(task) //will display the date as defined in the `displayValue` option defined for it.
-     */
-    displayValue(item: Partial<entityType>): string;
-    apiUpdateAllowed(item?: Partial<entityType>): boolean;
-    includedInApi(item?: Partial<entityType>): boolean;
-    /** Adapts the value for usage with html input
-     * @example
-     * @Fields.dateOnly()
-     * birthDate = new Date(1976,5,16)
-     * //...
-     * input.value = repo.fields.birthDate.toInput(person) // will return '1976-06-16'
-     */
-    toInput(value: valueType, inputType?: string): string;
-    /** Adapts the value for usage with html input
-     * @example
-     * @Fields.dateOnly()
-     * birthDate = new Date(1976,5,16)
-     * //...
-     * person.birthDate = repo.fields.birthDate.fromInput(personFormState) // will return Date
-     */
-    fromInput(inputValue: string, inputType?: string): valueType;
-}
-export interface ValueConverter<valueType> {
-    fromJson?(val: any): valueType;
-    toJson?(val: valueType): any;
-    fromDb?(val: any): valueType;
-    toDb?(val: valueType): any;
-    toInput?(val: valueType, inputType?: string): string;
-    fromInput?(val: string, inputType?: string): valueType;
-    displayValue?(val: valueType): string;
-    readonly fieldTypeInDb?: string;
-    readonly inputType?: string;
-}
-export declare type FieldValidator<entityType = any, valueType = any> = (entity: entityType, fieldRef: FieldRef<entityType, valueType>) => void | Promise<void>;
-export declare type ValueOrExpression<valueType> = valueType | (() => valueType);
-export declare function valueOrExpressionToValue<valueType>(f: ValueOrExpression<valueType>): valueType;
-export interface ValueListItem {
-    id?: any;
-    caption?: any;
-}

package/esm/src/column.d.ts

@@ -1,19 +0,0 @@
-import type { idType, Repository } from './remult3/remult3';
-export declare function makeTitle(name: string): string;
-export declare class LookupColumn<T> {
-    private repository;
-    private isReferenceRelation;
-    private allowNull;
-    toJson(): any;
-    setId(val: any): void;
-    waitLoadOf(id: any): Promise<T>;
-    get(id: any): any;
-    storedItem?: {
-        item: T;
-    };
-    set(item: T): void;
-    id: idType<T>;
-    constructor(repository: Repository<T>, isReferenceRelation: any, allowNull: any);
-    get item(): T;
-    waitLoad(): Promise<T>;
-}