remult 0.24.0 → 0.24.1

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>;
-}

package/esm/src/context.d.ts

@@ -1,134 +0,0 @@
-import type { ClassType } from '../classType';
-import type { DataProvider } from './data-interfaces';
-import type { EntityMetadata, EntityRef, FindOptions, Repository } from './remult3/remult3';
-import type { ExternalHttpProvider } from './buildRestDataProvider';
-import type { SubscriptionClient, Unsubscribe } from './live-query/SubscriptionChannel';
-import type { SubscriptionServer } from './live-query/SubscriptionServer';
-export declare class RemultAsyncLocalStorage {
-    private readonly remultObjectStorage;
-    static enable(): void;
-    static disable(): void;
-    constructor(remultObjectStorage: myAsyncLocalStorage<Remult>);
-    run(remult: Remult, callback: VoidFunction): void;
-    getRemult(): Remult;
-    static instance: RemultAsyncLocalStorage;
-}
-type myAsyncLocalStorage<T> = {
-    run<R>(store: T, callback: (...args: any[]) => R, ...args: any[]): R;
-    getStore(): T | undefined;
-};
-export declare function isBackend(): boolean;
-export declare class Remult {
-    /**Return's a `Repository` of the specific entity type
-     * @example
-     * const taskRepo = remult.repo(Task);
-     * @see [Repository](https://remult.dev/docs/ref_repository.html)
-     * @param entity - the entity to use
-     * @param dataProvider - an optional alternative data provider to use. Useful for writing to offline storage or an alternative data provider
-     */
-    repo<T>(entity: ClassType<T>, dataProvider?: DataProvider): Repository<T>;
-    /** Returns the current user's info */
-    user?: UserInfo;
-    /** Checks if a user was authenticated */
-    authenticated(): boolean;
-    /** checks if the user has any of the roles specified in the parameters
-     * @example
-     * remult.isAllowed("admin")
-     * @see
-     * [Allowed](https://remult.dev/docs/allowed.html)
-     */
-    isAllowed(roles?: Allowed): boolean;
-    /** checks if the user matches the allowedForInstance callback
-     * @see
-     * [Allowed](https://remult.dev/docs/allowed.html)
-     */
-    isAllowedForInstance(instance: any, allowed?: AllowedForInstance<any>): boolean;
-    /** The current data provider */
-    dataProvider: DataProvider;
-    /** Creates a new instance of the `remult` object.
-     *
-     * Can receive either an HttpProvider or a DataProvider as a parameter - which will be used to fetch data from.
-     *
-     * If no provider is specified, `fetch` will be used as an http provider
-     */
-    constructor(http: ExternalHttpProvider | typeof fetch | ApiClient);
-    constructor(p: DataProvider);
-    constructor();
-    subscriptionServer?: SubscriptionServer;
-    /** Used to call a `backendMethod` using a specific `remult` object
-     * @example
-     * await remult.call(TasksController.setAll, undefined, true);
-     * @param backendMethod - the backend method to call
-     * @param classInstance - the class instance of the backend method, for static backend methods use undefined
-     * @param args - the arguments to send to the backend method
-     */
-    call<T extends (...args: any[]) => Promise<any>>(backendMethod: T, classInstance?: any, ...args: GetArguments<T>): ReturnType<T>;
-    /** A helper callback that can be used to debug and trace all find operations. Useful in debugging scenarios */
-    static onFind: (metadata: EntityMetadata, options: FindOptions<any>) => void;
-    clearAllCache(): any;
-    /** A helper callback that is called whenever an entity is created. */
-    static entityRefInit?: (ref: EntityRef<any>, row: any) => void;
-    /** context information that can be used to store custom information that will be disposed as part of the `remult` object */
-    readonly context: RemultContext;
-    /** The api client that will be used by `remult` to perform calls to the `api` */
-    apiClient: ApiClient;
-    static run<T>(callback: () => T, options: {
-        dataProvider: DataProvider;
-    }): T;
-}
-export type GetArguments<T> = T extends (...args: infer FirstArgument) => any ? FirstArgument : never;
-export interface RemultContext {
-}
-export interface ApiClient {
-    /** The http client to use when making api calls.
-     * @example
-     * remult.apiClient.httpClient = axios;
-     * @example
-     * remult.apiClient.httpClient = httpClient;//angular http client
-     * @example
-     * remult.apiClient.httpClient = fetch; //this is the default
-     */
-    httpClient?: ExternalHttpProvider | typeof fetch;
-    /** The base url to for making api calls */
-    url?: string;
-    subscriptionClient?: SubscriptionClient;
-    wrapMessageHandling?: (x: VoidFunction) => void;
-}
-export declare const allEntities: ClassType<any>[];
-export interface ControllerOptions {
-    key: string;
-}
-export declare const classHelpers: Map<any, ClassHelper>;
-export declare class ClassHelper {
-    classes: Map<any, ControllerOptions>;
-}
-export declare function setControllerSettings(target: any, options: ControllerOptions): void;
-export interface UserInfo {
-    id: string;
-    name?: string;
-    roles?: string[];
-}
-export declare type Allowed = boolean | string | string[] | ((c?: Remult) => boolean);
-export declare type AllowedForInstance<T> = boolean | string | string[] | ((entity?: T, c?: Remult) => boolean);
-export declare class Allow {
-    static everyone: () => boolean;
-    static authenticated: (...args: any[]) => any;
-}
-export declare const queryConfig: {
-    defaultPageSize: number;
-};
-export interface EventDispatcher {
-    observe(what: () => any | Promise<any>): Promise<Unsubscribe>;
-}
-export declare class EventSource {
-    listeners: (() => {})[];
-    fire(): Promise<void>;
-    dispatcher: EventDispatcher;
-}
-export interface itemChange {
-    id: any;
-    oldId: any;
-    deleted: boolean;
-}
-export declare function doTransaction(remult: Remult, what: () => Promise<void>): Promise<void>;
-export {};

package/esm/src/data-api.d.ts

@@ -1,39 +0,0 @@
-import type { Remult } from './context';
-import type { ErrorInfo } from './data-interfaces';
-import type { FindOptions, Repository } from './remult3/remult3';
-export declare class DataApi<T = any> {
-    private repository;
-    private remult;
-    constructor(repository: Repository<T>, remult: Remult);
-    httpGet(res: DataApiResponse, req: DataApiRequest, serializeContext: () => Promise<any>): Promise<void>;
-    httpPost(res: DataApiResponse, req: DataApiRequest, body: any, serializeContext: () => Promise<any>): Promise<void>;
-    static defaultGetLimit: number;
-    get(response: DataApiResponse, id: any): Promise<void>;
-    count(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    getArrayImpl(response: DataApiResponse, request: DataApiRequest, filterBody: any): Promise<{
-        r: any[];
-        findOptions: FindOptions<T>;
-    }>;
-    private includeNone;
-    getArray(response: DataApiResponse, request: DataApiRequest, filterBody?: any): Promise<void>;
-    liveQuery(response: DataApiResponse, request: DataApiRequest, filterBody: any, serializeContext: () => Promise<any>, queryChannel: string): Promise<void>;
-    private buildWhere;
-    private doOnId;
-    put(response: DataApiResponse, id: any, body: any): Promise<void>;
-    delete(response: DataApiResponse, id: any): Promise<void>;
-    post(response: DataApiResponse, body: any): Promise<void>;
-}
-export interface DataApiResponse {
-    success(data: any): void;
-    deleted(): void;
-    created(data: any): void;
-    notFound(): void;
-    error(data: ErrorInfo): void;
-    forbidden(): void;
-    progress(progress: number): void;
-}
-export interface DataApiRequest {
-    get(key: string): any;
-}
-export declare function determineSort(sortUrlParm: string, dirUrlParam: string): any;
-export declare function serializeError(data: ErrorInfo): ErrorInfo<any>;

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

@@ -1,41 +0,0 @@
-import type { Filter } from './filter/filter-interfaces';
-import type { EntityMetadata, MembersOnly } from './remult3/remult3';
-import { Sort } from './sort';
-export interface DataProvider {
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    ensureSchema?(entities: EntityMetadata[]): Promise<void>;
-    isProxy?: boolean;
-}
-export interface Storage {
-    ensureSchema(): Promise<void>;
-}
-export interface EntityDataProvider {
-    count(where: Filter): Promise<number>;
-    find(options?: EntityDataProviderFindOptions): Promise<Array<any>>;
-    update(id: any, data: any): Promise<any>;
-    delete(id: any): Promise<void>;
-    insert(data: any): Promise<any>;
-}
-export interface EntityDataProviderFindOptions {
-    where?: Filter;
-    limit?: number;
-    page?: number;
-    orderBy?: Sort;
-}
-export interface RestDataProviderHttpProvider {
-    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 extractSort(sort: any): Sort;
-export interface ErrorInfo<entityType = any> {
-    message?: string;
-    modelState?: {
-        [Properties in keyof Partial<MembersOnly<entityType>>]?: string;
-    };
-    stack?: string;
-    exception?: any;
-    httpStatusCode?: number;
-}

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

@@ -1,4 +0,0 @@
-export type CustomArrayFilter = (item: any) => boolean;
-export interface CustomArrayFilterObject {
-    arrayFilter: CustomArrayFilter;
-}

package/esm/src/data-providers/in-memory-database.d.ts

@@ -1,9 +0,0 @@
-import type { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
-import type { DataProvider, EntityDataProvider } from '../data-interfaces';
-import type { EntityMetadata } from '../remult3/remult3';
-export declare class InMemoryDataProvider implements DataProvider, __RowsOfDataForTesting {
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    rows: any;
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    toString(): string;
-}

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

@@ -1,12 +0,0 @@
-import type { DataProvider, EntityDataProvider } from '../data-interfaces';
-import type { EntityMetadata } from '../remult3/remult3';
-export interface JsonEntityStorage {
-    getItem(entityDbName: string): string | null;
-    setItem(entityDbName: string, json: string): any;
-}
-export declare class JsonDataProvider implements DataProvider {
-    private storage;
-    constructor(storage: JsonEntityStorage);
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-}