remult 0.24.0 → 0.24.2-exp.0

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

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

@@ -1,39 +0,0 @@
-import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, RestDataProviderHttpProvider } from '../data-interfaces';
-import { UrlBuilder } from '../../urlBuilder';
-import { type ApiClient } from '../context';
-import { Filter } from '../filter/filter-interfaces';
-import type { EntityMetadata } from '../remult3/remult3';
-export declare class RestDataProvider implements DataProvider {
-    private apiProvider;
-    constructor(apiProvider: () => ApiClient);
-    getEntityDataProvider(entity: EntityMetadata): RestEntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    isProxy: boolean;
-}
-export declare class RestEntityDataProvider implements EntityDataProvider {
-    private url;
-    private http;
-    private entity;
-    constructor(url: () => string, http: () => RestDataProviderHttpProvider, entity: EntityMetadata);
-    translateFromJson(row: any): {};
-    translateToJson(row: any): {};
-    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 declare class RestDataProviderHttpProviderUsingFetch implements RestDataProviderHttpProvider {
-    private fetch?;
-    constructor(fetch?: (input: RequestInfo, init?: RequestInit) => Promise<Response>);
-    get(url: string): Promise<any>;
-    put(url: string, data: any): Promise<any>;
-    delete(url: string): Promise<any>;
-    post(url: string, data: any): Promise<any>;
-    myFetch(url: string, options?: {
-        method?: string;
-        body?: string;
-    }): Promise<any>;
-}
-export declare function addFilterToUrlAndReturnTrueIfSuccessful(filter: any, url: UrlBuilder): boolean;
-export declare const liveQueryAction = "liveQuery-";

package/esm/src/data-providers/sql-database.d.ts

@@ -1,33 +0,0 @@
-import type { DataProvider, EntityDataProvider } from '../data-interfaces';
-import type { SqlCommand, SqlCommandWithParameters, SqlImplementation, SqlResult } from '../sql-command';
-import type { Remult } from '../context';
-import type { CustomSqlFilterBuilderFunction } from '../filter/filter-consumer-bridge-to-sql-request';
-import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
-import type { RepositoryOverloads } from '../remult3/RepositoryImplementation';
-export declare class SqlDatabase implements DataProvider {
-    private sql;
-    static getDb(remult?: Remult): SqlDatabase;
-    createCommand(): SqlCommand;
-    execute(sql: string): Promise<SqlResult>;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    getEntityDataProvider(entity: EntityMetadata): EntityDataProvider;
-    transaction(action: (dataProvider: DataProvider) => Promise<void>): Promise<void>;
-    static rawFilter(build: CustomSqlFilterBuilderFunction): EntityFilter<any>;
-    static filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>, sqlCommand?: SqlCommandWithParameters): Promise<string>;
-    /**
-     * `false` _(default)_ - No logging
-     *
-     * `true` - to log all queries to the console
-     *
-     * `oneLiner` - to log all queries to the console as one line
-     *
-     * a `function` - to log all queries to the console as a custom format
-     */
-    static LogToConsole: boolean | 'oneLiner' | ((duration: number, query: string, args: Record<string, any>) => void);
-    /**
-     * Threshold in milliseconds for logging queries to the console.
-     */
-    static durationThreshold: number;
-    constructor(sql: SqlImplementation);
-    private createdEntities;
-}

package/esm/src/data-providers/web-sql-data-provider.d.ts

@@ -1,21 +0,0 @@
-import type { __RowsOfDataForTesting } from '../__RowsOfDataForTesting';
-import type { SqlCommand, SqlImplementation } from '../sql-command';
-import type { Remult } from '../context';
-import type { EntityMetadata } from '../remult3/remult3';
-export declare class WebSqlDataProvider implements SqlImplementation, __RowsOfDataForTesting {
-    private databaseName;
-    rows: {
-        [tableName: string]: any;
-    };
-    constructor(databaseName: string, databaseSize?: number);
-    static getDb(remult?: Remult): any;
-    getLimitSqlSyntax(limit: number, offset: number): string;
-    entityIsUsedForTheFirstTime(entity: EntityMetadata): Promise<void>;
-    ensureSchema(entities: EntityMetadata<any>[]): Promise<void>;
-    dropTable(entity: EntityMetadata): Promise<void>;
-    createTable(entity: EntityMetadata<any>): Promise<void>;
-    createCommand(): SqlCommand;
-    transaction(action: (dataProvider: SqlImplementation) => Promise<void>): Promise<void>;
-    private addColumnSqlSyntax;
-    toString(): string;
-}

package/esm/src/entity.d.ts

@@ -1,126 +0,0 @@
-import type { Allowed, AllowedForInstance } from './context';
-import type { FieldMetadata } from './column-interfaces';
-import type { EntityFilter, EntityIdFields, EntityMetadata, EntityOrderBy, EntityRef, FieldsMetadata, LifecycleEvent } from './remult3/remult3';
-export interface EntityOptions<entityType = any> {
-    /**A human readable name for the entity */
-    caption?: string;
-    /**
-     * Determines if this Entity is available for get requests using Rest Api
-     * @description
-     * Determines if one has any access to the data of an entity.
-     * @see [allowed](http://remult.dev/docs/allowed.html)
-     * @see to restrict data based on a criteria, use [apiPrefilter](https://remult.dev/docs/ref_entity.html#apiprefilter)
-     * */
-    allowApiRead?: Allowed;
-    /**
-     * Determines if this entity can be updated through the api.
-     * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    allowApiUpdate?: AllowedForInstance<entityType>;
-    /** Determines if entries for this entity can be deleted through the api.
-     * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    allowApiDelete?: AllowedForInstance<entityType>;
-    /** Determines if new entries for this entity can be posted through the api.
-     * @see [allowed](http://remult.dev/docs/allowed.html)*/
-    allowApiInsert?: AllowedForInstance<entityType>;
-    /** sets  the `allowApiUpdate`, `allowApiDelete` and `allowApiInsert` properties in a single set */
-    allowApiCrud?: Allowed;
-    /** A filter that determines which rows can be queries using the api.
-     * @description
-     * Use apiPrefilter in cases where you to restrict data based on user profile
-     * @example
-     * apiPrefilter: { archive:false }
-     *
-     * @example
-     * apiPrefilter: ()=> remult.isAllowed("admin")?{}:{ archive:false }
-     * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
-     *
-     */
-    apiPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
-    /** A filter that will be used for all queries from this entity both from the API and from within the backend.
-     * @example
-     * backendPrefilter: { archive:false }
-     * @see [EntityFilter](http://remult.dev/docs/entityFilter.html)
-     */
-    backendPrefilter?: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>);
-    /** An order by to be used, in case no order by was specified
-     * @example
-     * defaultOrderBy: { name: "asc" }
-     *
-     * @example
-     * defaultOrderBy: { price: "desc", name: "asc" }
-     */
-    defaultOrderBy?: EntityOrderBy<entityType>;
-    /** An event that will be fired before the Entity will be saved to the database.
-     * If the `error` property of the entity's ref or any of its fields will be set, the save will be aborted and an exception will be thrown.
-     * this is the place to run logic that we want to run in any case before an entity is saved.
-     * @example
-     * @Entity<Task>("tasks", {
-     *   saving: async (task, e) => {
-     *     if (e.isNew) {
-     *       task.createdAt = new Date(); // Set the creation date for new tasks.
-     *     }
-     *     task.lastUpdated = new Date(); // Update the last updated date.
-     *   },
-     * })
-     * @param entity - The instance of the entity being saved.
-     * @param event - an @link LifeCycleEvent object
-     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
-     */
-    saving?: (entity: entityType, event: LifecycleEvent<entityType>) => Promise<any> | any;
-    /**
-     * A hook that runs after an entity has been successfully saved.
-     *
-     * @param entity The instance of the entity that was saved.
-     * @param event - an @link LifeCycleEvent object
-     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
-     */
-    saved?: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any;
-    /**
-     * A hook that runs before an entity is deleted.
-     *
-     * @param entity The instance of the entity being deleted.
-     * @param event - an @link LifeCycleEvent object
-     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
-     */
-    deleting?: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any;
-    /**
-     * A hook that runs after an entity has been successfully deleted.
-     *
-     * @param entity The instance of the entity that was deleted.
-     * @param event - an @link LifeCycleEvent object
-     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
-     */
-    deleted?: (entity: entityType, e: LifecycleEvent<entityType>) => Promise<any> | any;
-    /**
-     * A hook that runs to perform validation checks on an entity before saving.
-     * This hook is also executed on the frontend.
-     *
-     * @param entity The instance of the entity being validated.
-     * @param event - an @link LifeCycleEvent object
-     * @see [Entity Lifecycle Hooks](http://remult.dev/docs/lifecycle-hooks)
-     */
-    validation?: (entity: entityType, ref: LifecycleEvent<entityType>) => Promise<any> | any;
-    /** The name of the table in the database that holds the data for this entity.
-     * If no name is set, the `key` will be used instead.
-     * @example
-     * dbName:'myProducts'
-     *
-     * You can also add your schema name to the table name
-     * @example
-     * dbName:'public."myProducts"'
-     */
-    dbName?: string;
-    /** For entities that are based on SQL expressions instead of a physical table or view*/
-    sqlExpression?: string | ((entity: EntityMetadata<entityType>) => string | Promise<string>);
-    /** An arrow function that identifies the `id` column to use for this entity
-     * @example
-     * //Single column id
-     * @Entity<Products>("products", { id: {productCode: true} })
-     * @example
-     * //Multiple columns id
-     * @Entity<OrderDetails>("orderDetails", { id:{ orderId:true, productCode:true} })
-     */
-    id?: EntityIdFields<entityType> | ((entity: FieldsMetadata<entityType>) => FieldMetadata | FieldMetadata[]);
-    entityRefInit?: (ref: EntityRef<entityType>, row: entityType) => void;
-    apiRequireId?: Allowed;
-}

package/esm/src/filter/filter-consumer-bridge-to-sql-request.d.ts

@@ -1,51 +0,0 @@
-import type { FieldMetadata } from '../column-interfaces';
-import type { EntityMetadataOverloads, RepositoryOverloads } from '../remult3/RepositoryImplementation';
-import type { EntityFilter, MembersOnly } from '../remult3/remult3';
-import type { SqlCommandWithParameters } from '../sql-command';
-import type { Filter, FilterConsumer } from './filter-interfaces';
-export declare class FilterConsumerBridgeToSqlRequest implements FilterConsumer {
-    private r;
-    private nameProvider;
-    private where;
-    _addWhere: boolean;
-    promises: Promise<void>[];
-    resolveWhere(): Promise<string>;
-    constructor(r: SqlCommandWithParameters, nameProvider: EntityDbNamesBase);
-    custom(key: string, customItem: any): void;
-    or(orElements: Filter[]): void;
-    isNull(col: FieldMetadata): void;
-    isNotNull(col: FieldMetadata): void;
-    isIn(col: FieldMetadata, val: any[]): void;
-    isEqualTo(col: FieldMetadata, val: any): void;
-    isDifferentFrom(col: FieldMetadata, val: any): void;
-    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
-    isGreaterThan(col: FieldMetadata, val: any): void;
-    isLessOrEqualTo(col: FieldMetadata, val: any): void;
-    isLessThan(col: FieldMetadata, val: any): void;
-    containsCaseInsensitive(col: FieldMetadata, val: any): void;
-    notContainsCaseInsensitive(col: FieldMetadata, val: any): void;
-    private add;
-    private addToWhere;
-    databaseCustom(databaseCustom: CustomSqlFilterObject): void;
-}
-export type CustomSqlFilterBuilderFunction = (builder: CustomSqlFilterBuilder) => void | Promise<any>;
-export interface CustomSqlFilterObject {
-    buildSql: CustomSqlFilterBuilderFunction;
-}
-export declare class CustomSqlFilterBuilder {
-    private r;
-    constructor(r: SqlCommandWithParameters);
-    sql: string;
-    addParameterAndReturnSqlToken<valueType>(val: valueType, field?: FieldMetadata<valueType>): string;
-    filterToRaw<entityType>(repo: RepositoryOverloads<entityType>, condition: EntityFilter<entityType>): Promise<string>;
-}
-export declare function isDbReadonly<entityType>(field: FieldMetadata, dbNames: EntityDbNames<entityType>): boolean;
-export declare type EntityDbNamesBase = {
-    $entityName: string;
-    $dbNameOf(field: FieldMetadata<any> | string): string;
-    toString(): string;
-};
-export declare type EntityDbNames<entityType> = {
-    [Properties in keyof Required<MembersOnly<entityType>>]: string;
-} & EntityDbNamesBase;
-export declare function dbNamesOf<entityType>(repo: EntityMetadataOverloads<entityType>): Promise<EntityDbNames<entityType>>;

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

@@ -1,74 +0,0 @@
-import type { FieldMetadata } from '../column-interfaces';
-import { Remult } from '../context';
-import type { EntityFilter, EntityMetadata } from '../remult3/remult3';
-export declare class Filter {
-    private apply;
-    constructor(apply: (add: FilterConsumer) => void);
-    __applyToConsumer(add: FilterConsumer): void;
-    static resolve<entityType>(filter: EntityFilter<entityType> | (() => EntityFilter<entityType> | Promise<EntityFilter<entityType>>)): Promise<EntityFilter<entityType>>;
-    static createCustom<entityType>(rawFilterTranslator: (unused: never, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): (() => EntityFilter<entityType>) & customFilterInfo<entityType>;
-    static createCustom<entityType, argsType>(rawFilterTranslator: (args: argsType, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>, key?: string): ((y: argsType) => EntityFilter<entityType>) & customFilterInfo<entityType>;
-    static fromEntityFilter<T>(entity: EntityMetadata<T>, whereItem: EntityFilter<T>): Filter;
-    toJson(): any;
-    static entityFilterToJson<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>): any;
-    static entityFilterFromJson<T>(entityDefs: EntityMetadata<T>, packed: any): EntityFilter<T>;
-    static translateCustomWhere<T>(r: Filter, entity: EntityMetadata<T>, remult: Remult): Promise<Filter>;
-}
-export interface FilterConsumer {
-    or(orElements: Filter[]): any;
-    isEqualTo(col: FieldMetadata, val: any): void;
-    isDifferentFrom(col: FieldMetadata, val: any): void;
-    isNull(col: FieldMetadata): void;
-    isNotNull(col: FieldMetadata): void;
-    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
-    isGreaterThan(col: FieldMetadata, val: any): void;
-    isLessOrEqualTo(col: FieldMetadata, val: any): void;
-    isLessThan(col: FieldMetadata, val: any): void;
-    containsCaseInsensitive(col: FieldMetadata, val: any): void;
-    notContainsCaseInsensitive(col: FieldMetadata, val: any): void;
-    isIn(col: FieldMetadata, val: any[]): void;
-    custom(key: string, customItem: any): void;
-    databaseCustom(databaseCustom: any): void;
-}
-export declare class AndFilter extends Filter {
-    readonly filters: Filter[];
-    constructor(...filters: Filter[]);
-    add(filter: Filter): void;
-}
-export declare class OrFilter extends Filter {
-    readonly filters: Filter[];
-    constructor(...filters: Filter[]);
-}
-export declare const customUrlToken = "$custom$";
-export declare const customDatabaseFilterToken = "$db$";
-export declare class FilterSerializer implements FilterConsumer {
-    result: any;
-    constructor();
-    databaseCustom(databaseCustom: any): void;
-    custom(key: any, customItem: any): void;
-    hasUndefined: boolean;
-    add(key: string, val: any): void;
-    or(orElements: Filter[]): void;
-    isNull(col: FieldMetadata): void;
-    isNotNull(col: FieldMetadata): void;
-    isIn(col: FieldMetadata, val: any[]): void;
-    isEqualTo(col: FieldMetadata, val: any): void;
-    isDifferentFrom(col: FieldMetadata, val: any): void;
-    isGreaterOrEqualTo(col: FieldMetadata, val: any): void;
-    isGreaterThan(col: FieldMetadata, val: any): void;
-    isLessOrEqualTo(col: FieldMetadata, val: any): void;
-    isLessThan(col: FieldMetadata, val: any): void;
-    containsCaseInsensitive(col: FieldMetadata, val: any): void;
-    notContainsCaseInsensitive(col: FieldMetadata, val: any): void;
-}
-export declare function entityFilterToJson<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>): any;
-export declare function buildFilterFromRequestParameters(entity: EntityMetadata, filterInfo: {
-    get: (key: string) => any;
-}): EntityFilter<any>;
-export interface customFilterInfo<entityType> {
-    rawFilterInfo: {
-        key: string;
-        rawFilterTranslator: (args: any, r: Remult) => EntityFilter<entityType> | Promise<EntityFilter<entityType>>;
-    };
-}
-export declare function __updateEntityBasedOnWhere<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>, r: T): void;

package/esm/src/live-query/LiveQueryClient.d.ts

@@ -1 +0,0 @@
-export {};

package/esm/src/live-query/SseSubscriptionClient.d.ts

@@ -1,5 +0,0 @@
-import type { SubscriptionClient, SubscriptionClientConnection } from './SubscriptionChannel';
-export declare class SseSubscriptionClient implements SubscriptionClient {
-    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
-}
-export declare const ConnectionNotFoundError = "client connection not found";

package/esm/src/live-query/SubscriptionChannel.d.ts

@@ -1,41 +0,0 @@
-import type { Remult } from '../context';
-export declare const streamUrl = "stream";
-export interface SubscriptionListener<type> {
-    next(message: type): void;
-    error(err: any): void;
-    complete(): void;
-}
-export type Unsubscribe = VoidFunction;
-export interface SubscriptionClientConnection {
-    subscribe(channel: string, onMessage: (message: any) => void, onError: (err: any) => void): Promise<Unsubscribe>;
-    close(): void;
-}
-export interface SubscriptionClient {
-    openConnection(onReconnect: VoidFunction): Promise<SubscriptionClientConnection>;
-}
-export declare const liveQueryKeepAliveRoute = "_liveQueryKeepAlive";
-export declare type LiveQueryChange = {
-    type: 'all';
-    data: any[];
-} | {
-    type: 'add';
-    data: any;
-} | {
-    type: 'replace';
-    data: {
-        oldId: any;
-        item: any;
-    };
-} | {
-    type: 'remove';
-    data: {
-        id: any;
-    };
-};
-export declare class SubscriptionChannel<messageType> {
-    channelKey: string;
-    constructor(channelKey: string);
-    publish(message: messageType, remult?: Remult): void;
-    subscribe(next: (message: messageType) => void, remult?: Remult): Promise<Unsubscribe>;
-    subscribe(listener: Partial<SubscriptionListener<messageType>>): Promise<Unsubscribe>;
-}