remult 0.24.0 → 0.24.2-exp.0

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

@@ -1,38 +0,0 @@
-export interface SubscriptionServer {
-    publishMessage<T>(channel: string, message: T): Promise<void>;
-}
-export interface LiveQueryStorage {
-    add(query: StoredQuery): Promise<void>;
-    remove(queryId: string): Promise<void>;
-    forEach(entityKey: string, callback: (args: {
-        query: StoredQuery;
-        setData(data: any): Promise<void>;
-    }) => Promise<void>): Promise<void>;
-    keepAliveAndReturnUnknownQueryIds(queryIds: string[]): Promise<string[]>;
-}
-export declare class InMemoryLiveQueryStorage implements LiveQueryStorage {
-    debugFileSaver: (x: any) => void;
-    debug(): void;
-    keepAliveAndReturnUnknownQueryIds(ids: string[]): Promise<string[]>;
-    queries: (StoredQuery & {
-        lastUsed: string;
-    })[];
-    constructor();
-    add(query: StoredQuery): Promise<void>;
-    removeCountForTesting: number;
-    remove(id: any): Promise<void>;
-    forEach(entityKey: string, handle: (args: {
-        query: StoredQuery;
-        setData(data: any): Promise<void>;
-    }) => Promise<void>): Promise<void>;
-}
-export interface StoredQuery {
-    entityKey: string;
-    id: string;
-    data: any;
-}
-export interface QueryData {
-    findOptionsJson: any;
-    requestJson: any;
-    lastIds: any[];
-}

package/esm/src/remult-proxy.d.ts

@@ -1,2 +0,0 @@
-import type { Remult } from './context';
-export declare const remult: Remult;

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

@@ -1,9 +0,0 @@
-type Decorator<T = any> = (a: T, b: string, c?: any) => void;
-type Decorators<T> = T extends new (...args: any[]) => infer R ? {
-    [K in keyof R]?: Decorator;
-} : never;
-type StaticDecorators<T> = {
-    [K in keyof T]?: Decorator;
-};
-export declare function describeClass<classType>(classType: classType, classDecorator: ((x: any, context?: any) => any) | undefined, members?: Decorators<classType> | undefined, staticMembers?: StaticDecorators<classType>): void;
-export {};

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

@@ -1,133 +0,0 @@
-import type { ClassType } from '../../classType';
-import type { FieldOptions } from '../column-interfaces';
-import type { Remult } from '../context';
-import type { FindOptions, RelationOptions, ClassFieldDecorator, ClassFieldDecoratorContextStub } from './remult3';
-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))[]): ClassFieldDecorator<entityType, valueType | undefined>;
-    static json<entityType = any, valueType = any>(...options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, valueType | undefined>;
-    static dateOnly<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
-    static date<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
-    static integer<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
-    static autoIncrement<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
-    static number<entityType = any>(...options: (FieldOptions<entityType, Number> | ((options: FieldOptions<entityType, Number>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, number | undefined>;
-    static createdAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
-    static updatedAt<entityType = any>(...options: (FieldOptions<entityType, Date> | ((options: FieldOptions<entityType, Date>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, Date | undefined>;
-    static uuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
-    static cuid<entityType = any>(...options: (FieldOptions<entityType, string> | ((options: FieldOptions<entityType, string>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
-    static string<entityType = any>(...options: (StringFieldOptions<entityType> | ((options: StringFieldOptions<entityType>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, string | undefined>;
-    static boolean<entityType = any>(...options: (FieldOptions<entityType, boolean> | ((options: FieldOptions<entityType, boolean>, remult: Remult) => void))[]): ClassFieldDecorator<entityType, boolean | undefined>;
-}
-export declare class Relations {
-    /**
-     * Define a to-one relation between entities, indicating a one-to-one relationship.
-     * If no field or fields are provided, it will automatically create a field in the database
-     * to represent the relation.
-     *
-     * @param toEntityType A function that returns the target entity type.
-     * @param options (Optional): An object containing options for configuring the to-one relation.
-     * @returns A decorator function to apply the to-one relation to an entity field.
-     *
-     * Example usage:
-     * ```
-     * @Relations.toOne(() => Customer)
-     * customer?: Customer;
-     * ```
-     * ```
-     * Fields.string()
-     * customerId?: string;
-     *
-     * @Relations.toOne(() => Customer, "customerId")
-     * customer?: Customer;
-     * ```
-     * ```
-     * Fields.string()
-     * customerId?: string;
-     *
-     * @Relations.toOne(() => Customer, {
-     *   field: "customerId",
-     *   defaultIncluded: true
-     * })
-     * customer?: Customer;
-     * ```
-     * ```
-     * Fields.string()
-     * customerId?: string;
-     *
-     * @Relations.toOne(() => Customer, {
-     *   fields: {
-     *     customerId: "id",
-     *   },
-     * })
-     * customer?: Customer;
-     * ```
-    */
-    static toOne<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options?: FieldOptions<entityType, toEntityType> & Pick<RelationOptions<entityType, toEntityType, any, any>, 'defaultIncluded'> | RelationOptions<entityType, toEntityType, entityType> | keyof entityType): (target: any, context: string | ClassFieldDecoratorContextStub<any, toEntityType>, c?: any) => void;
-    /**
-     * Define a toMany relation between entities, indicating a one-to-many relationship.
-     * This method allows you to establish a relationship where one entity can have multiple related entities.
-     *
-     * @param toEntityType A function that returns the target entity type.
-     * @param fieldInToEntity (Optional) The field in the target entity that represents the relation.
-     *                       Use this if you want to specify a custom field name for the relation.
-     * @returns A decorator function to apply the toMany relation to an entity field.
-     *
-     * Example usage:
-     * ```
-     * @Relations.toMany(() => Order)
-     * orders?: Order[];
-     *
-     * // or with a custom field name:
-     * @Relations.toMany(() => Order, "customerId")
-     * orders?: Order[];
-     * ```
-     */
-    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, fieldInToEntity?: keyof toEntityType): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
-    /**
-     * Define a toMany relation between entities, indicating a one-to-many relationship.
-     * This method allows you to establish a relationship where one entity can have multiple related entities.
-     * You can also specify various options to customize the relation and control related data retrieval.
-     *
-     * @param toEntityType A function that returns the target entity type.
-     * @param options An object containing options for configuring the toMany relation.
-     *                - field (Optional): The field in the target entity that represents the relation.
-     *                  Use this if you want to specify a custom field name for the relation.
-     *                - findOptions (Optional): Customize the options for finding related entities.
-     *                  You can set limits, order, where conditions, and more.
-     * @returns A decorator function to apply the toMany relation to an entity field.
-     *
-     * Example usage:
-     * ```
-     * @Relations.toMany(() => Order, {
-     *   field: "customerOrders",
-     *   findOptions: {
-     *     limit: 10,
-     *     orderBy: { amount: "desc" },
-     *     where: { completed: true },
-     *   },
-     * })
-     * orders?: Order[];
-     * ```
-     */
-    static toMany<entityType, toEntityType>(toEntityType: () => ClassType<toEntityType>, options: RelationOptions<entityType, toEntityType, toEntityType, FindOptions<toEntityType>>): ClassFieldDecorator<entityType, toEntityType[] | undefined>;
-}
-/**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>) | undefined, ...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;

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

@@ -1,4 +0,0 @@
-import { EntityBase } from './RepositoryImplementation';
-export declare class IdEntity extends EntityBase {
-    id: string;
-}

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

@@ -1,289 +0,0 @@
-import type { ClassType } from '../../classType';
-import { LookupColumn } from '../column';
-import type { FieldMetadata, FieldOptions, ValueConverter, ValueListItem } from '../column-interfaces';
-import { Remult } from '../context';
-import type { EntityOptions } from '../entity';
-import type { ControllerRef, ControllerRefForControllerBase, EntityFilter, EntityMetadata, EntityOrderBy, EntityRef, EntityRefForEntityBase, FieldRef, FieldsMetadata, FieldsRef, FieldsRefForEntityBase, FindFirstOptions, FindFirstOptionsBase, FindOptions, IdMetadata, LiveQuery, LoadOptions, MembersOnly, QueryOptions, QueryResult, Repository, RepositoryRelations, Subscribable } from './remult3';
-import type { RefSubscriber } from './remult3';
-import type { entityEventListener } from '../__EntityValueProvider';
-import type { DataProvider, EntityDataProvider, EntityDataProviderFindOptions, ErrorInfo } from '../data-interfaces';
-import type { Unsubscribe } from '../live-query/SubscriptionChannel';
-import type { columnInfo } from './columnInfo';
-import { RelationLoader } from './relation-loader';
-import { getInternalKey } from './repository-internals';
-export declare class RepositoryImplementation<entityType> implements Repository<entityType> {
-    private entity;
-    remult: Remult;
-    private dataProvider;
-    private _info;
-    private defaultFindOptions?;
-    [getInternalKey](): this;
-    createAfterFilter(orderBy: EntityOrderBy<entityType>, lastRow: entityType): Promise<EntityFilter<entityType>>;
-    relations(item: entityType): RepositoryRelations<entityType>;
-    private __edp;
-    private get edp();
-    constructor(entity: ClassType<entityType>, remult: Remult, dataProvider: DataProvider, _info: EntityFullInfo<entityType>, defaultFindOptions?: FindOptions<entityType>);
-    idCache: Map<any, any>;
-    getCachedById(id: any, doNotLoadIfNotFound: boolean): entityType;
-    getCachedByIdAsync(id: any, doNotLoadIfNotFound: boolean): Promise<entityType>;
-    addToCache(item: entityType): void;
-    get metadata(): EntityMetadata<entityType>;
-    listeners: entityEventListener<entityType>[];
-    addEventListener(listener: entityEventListener<entityType>): () => void;
-    query(options?: QueryOptions<entityType>): QueryResult<entityType>;
-    getEntityRef(entity: entityType): EntityRef<entityType>;
-    delete(id: entityType extends {
-        id?: number;
-    } ? number : entityType extends {
-        id?: string;
-    } ? string : string | number): Promise<void>;
-    delete(item: entityType): Promise<void>;
-    insert(item: Partial<MembersOnly<entityType>>[]): Promise<entityType[]>;
-    insert(item: Partial<MembersOnly<entityType>>): Promise<entityType>;
-    get fields(): FieldsMetadata<entityType>;
-    validate(entity: Partial<MembersOnly<entityType>>, ...fields: Extract<keyof MembersOnly<entityType>, string>[]): Promise<ErrorInfo<entityType> | undefined>;
-    update(id: entityType extends {
-        id?: number;
-    } ? number : entityType extends {
-        id?: string;
-    } ? string : string | number, item: Partial<MembersOnly<entityType>>): Promise<entityType>;
-    update(originalItem: Partial<MembersOnly<entityType>>, item: Partial<MembersOnly<entityType>>): Promise<entityType>;
-    private getRefForExistingRow;
-    save(item: Partial<MembersOnly<entityType>>[]): Promise<entityType[]>;
-    save(item: Partial<MembersOnly<entityType>>): Promise<entityType>;
-    liveQuery(options?: FindOptions<entityType>): LiveQuery<entityType>;
-    rawFind(options: FindOptions<entityType>, skipOrderByAndLimit: boolean, loader: RelationLoader): Promise<entityType[]>;
-    find(options: FindOptions<entityType>, skipOrderByAndLimit?: boolean): Promise<entityType[]>;
-    buildEntityDataProviderFindOptions(options: FindOptions<entityType>): Promise<EntityDataProviderFindOptions>;
-    fromJsonArray(jsonItems: any[], loadOptions: LoadOptions<entityType>): Promise<entityType[]>;
-    private loadManyToOneForManyRows;
-    private mapRawDataToResult;
-    toJson(item: entityType | entityType[] | Promise<entityType> | Promise<entityType[]>): any;
-    fromJson(json: any, newRow?: boolean): any;
-    count(where?: EntityFilter<entityType>): Promise<number>;
-    private cache;
-    findFirst(where?: EntityFilter<entityType>, options?: FindFirstOptions<entityType>, skipOrderByAndLimit?: boolean): Promise<entityType>;
-    private fieldsOf;
-    create(item?: Partial<MembersOnly<entityType>>): entityType;
-    fixTypes(item: any): Promise<any>;
-    findId(id: any, options?: FindFirstOptionsBase<entityType>): Promise<entityType>;
-}
-export type EntityOptionsFactory = (remult: Remult) => EntityOptions;
-export declare const columnsOfType: Map<any, columnInfo[]>;
-export declare function createOldEntity<T>(entity: ClassType<T>, remult: Remult): EntityFullInfo<T>;
-declare abstract class rowHelperBase<T> {
-    protected columnsInfo: FieldOptions[];
-    instance: T;
-    protected remult: Remult;
-    protected isNewRow: boolean;
-    _error: string;
-    get error(): string;
-    set error(val: string);
-    constructor(columnsInfo: FieldOptions[], instance: T, remult: Remult, isNewRow: boolean);
-    _subscribers: SubscribableImp;
-    subscribe(listener: RefSubscriber): Unsubscribe;
-    _isLoading: boolean;
-    initSubscribers(): void;
-    get isLoading(): boolean;
-    set isLoading(val: boolean);
-    lookups: Map<string, LookupColumn<any>>;
-    waitLoad(): Promise<void>;
-    errors: {
-        [key: string]: string;
-    };
-    protected __assertValidity(): void;
-    buildErrorInfoObject(): ErrorInfo<any>;
-    abstract get fields(): FieldsRef<T>;
-    catchSaveErrors(err: any): any;
-    __clearErrorsAndReportChanged(): void;
-    _reportChangedToEntityAndFields(): void;
-    hasErrors(): boolean;
-    copyDataToObject(isNew?: boolean): any;
-    originalValues: any;
-    saveOriginalData(): void;
-    saveMoreOriginalData(): void;
-    validate(): Promise<ErrorInfo<any>>;
-    __validateEntity(): Promise<void>;
-    __performColumnAndEntityValidations(): Promise<void>;
-    toApiJson(includeRelatedEntities?: boolean): any;
-    _updateEntityBasedOnApi(body: any, ignoreApiAllowed?: boolean): Promise<void>;
-}
-export declare class rowHelperImplementation<T> extends rowHelperBase<T> implements EntityRef<T> {
-    private info;
-    repository: RepositoryImplementation<T>;
-    private edp;
-    private _isNew;
-    constructor(info: EntityFullInfo<T>, instance: T, repository: RepositoryImplementation<T>, edp: EntityDataProvider, remult: Remult, _isNew: boolean);
-    get relations(): RepositoryRelations<T>;
-    get apiUpdateAllowed(): boolean;
-    get apiDeleteAllowed(): boolean;
-    get apiInsertAllowed(): boolean;
-    metadata: EntityMetadata<T>;
-    getId(): any;
-    saveMoreOriginalData(): void;
-    private _wasDeleted;
-    wasDeleted(): boolean;
-    undoChanges(): void;
-    reload(): Promise<T>;
-    private _columns;
-    get fields(): FieldsRef<T>;
-    private _saving;
-    save(onlyTheseFieldsSentOnlyInTheCaseOfProxySaveWithPartialObject?: string[]): Promise<T>;
-    private buildLifeCycleEvent;
-    private getIdFilter;
-    delete(): Promise<void>;
-    loadDataFrom(data: any, loadItems?: FieldMetadata[]): Promise<void>;
-    id: any;
-    originalId: any;
-    getOriginalId(): any;
-    private calcServerExpression;
-    isNew(): boolean;
-    wasChanged(): boolean;
-    __performColumnAndEntityValidations(): Promise<void>;
-}
-export declare function getFields<fieldsContainerType>(container: fieldsContainerType, remult?: Remult): FieldsRef<fieldsContainerType>;
-export declare function getControllerRef<fieldsContainerType>(container: fieldsContainerType, remultArg?: Remult): ControllerRef<fieldsContainerType>;
-export declare class controllerRefImpl<T = any> extends rowHelperBase<T> implements ControllerRef<T> {
-    constructor(columnsInfo: FieldOptions[], instance: any, remult: Remult);
-    __performColumnAndEntityValidations(): Promise<void>;
-    fields: FieldsRef<T>;
-}
-export declare class FieldRefImplementation<entityType, valueType> implements FieldRef<entityType, valueType> {
-    private settings;
-    metadata: FieldMetadata;
-    container: any;
-    private helper;
-    private rowBase;
-    constructor(settings: FieldOptions, metadata: FieldMetadata, container: any, helper: EntityRef<entityType>, rowBase: rowHelperBase<entityType>);
-    _subscribers: SubscribableImp;
-    subscribe(listener: RefSubscriber): Unsubscribe;
-    valueIsNull(): boolean;
-    originalValueIsNull(): boolean;
-    load(): Promise<valueType>;
-    target: ClassType<any>;
-    reportObserved(): void;
-    reportChanged(): void;
-    get error(): string;
-    set error(error: string);
-    get displayValue(): string;
-    get value(): any;
-    set value(value: any);
-    get originalValue(): any;
-    private rawOriginalValue;
-    setId(id: string | number): void;
-    getId(): any;
-    get inputValue(): string;
-    set inputValue(val: string);
-    valueChanged(): boolean;
-    entityRef: EntityRef<any>;
-    __performValidation(): Promise<void>;
-    validate(): Promise<boolean>;
-}
-export declare const CaptionTransformer: {
-    transformCaption: (remult: Remult, key: string, caption: string) => string;
-};
-export declare function buildCaption(caption: string | ((remult: Remult) => string), key: string, remult: Remult): string;
-export declare class columnDefsImpl implements FieldMetadata {
-    private settings;
-    private entityDefs;
-    private remult;
-    constructor(settings: FieldOptions, entityDefs: EntityFullInfo<any>, remult: Remult);
-    apiUpdateAllowed(item?: any): boolean;
-    displayValue(item: any): string;
-    includedInApi(item?: any): boolean;
-    toInput(value: any, inputType?: string): string;
-    fromInput(inputValue: string, inputType?: string): any;
-    getDbName(): Promise<string>;
-    options: FieldOptions<any, any>;
-    target: ClassType<any>;
-    readonly: boolean;
-    valueConverter: Required<ValueConverter<any>>;
-    allowNull: boolean;
-    caption: string;
-    get dbName(): any;
-    inputType: string;
-    key: string;
-    get dbReadOnly(): boolean;
-    isServerExpression: boolean;
-    valueType: any;
-}
-declare class EntityFullInfo<T> implements EntityMetadata<T> {
-    columnsInfo: FieldOptions[];
-    entityInfo: EntityOptions;
-    private remult;
-    readonly entityType: ClassType<T>;
-    readonly key: string;
-    options: EntityOptions<T>;
-    constructor(columnsInfo: FieldOptions[], entityInfo: EntityOptions, remult: Remult, entityType: ClassType<T>, key: string);
-    apiUpdateAllowed(item: T): boolean;
-    get apiReadAllowed(): boolean;
-    apiDeleteAllowed(item: T): boolean;
-    apiInsertAllowed(item: T): boolean;
-    getEntityMetadataWithoutBreakingTheEntity(item: T): EntityRef<T>;
-    dbNamePromise: Promise<string>;
-    getDbName(): Promise<string>;
-    idMetadata: IdMetadata<T>;
-    fields: FieldsMetadata<T>;
-    dbName: string;
-    caption: string;
-}
-export declare function FieldType<valueType = any>(...options: (FieldOptions<any, valueType> | ((options: FieldOptions<any, valueType>, remult: Remult) => void))[]): (target: any, context?: any) => any;
-export declare function isAutoIncrement(f: FieldMetadata): boolean;
-export declare function ValueListFieldType<valueType extends ValueListItem = any>(...options: (ValueListFieldOptions<any, valueType> | ((options: FieldOptions<any, valueType>, remult: Remult) => void))[]): (type: ClassType<valueType>, context?: any) => void;
-export interface ValueListFieldOptions<entityType, valueType> extends FieldOptions<entityType, valueType> {
-    getValues?: () => valueType[];
-}
-export declare class ValueListInfo<T extends ValueListItem> implements ValueConverter<T> {
-    private valueListType;
-    static get<T extends ValueListItem>(type: ClassType<T>): ValueListInfo<T>;
-    private byIdMap;
-    private values;
-    isNumeric: boolean;
-    private constructor();
-    getValues(): T[];
-    byId(key: any): T;
-    fromJson(val: any): T;
-    toJson(val: T): any;
-    fromDb(val: any): T;
-    toDb(val: T): any;
-    toInput(val: T, inputType: string): string;
-    fromInput(val: string, inputType: string): T;
-    displayValue?(val: T): string;
-    fieldTypeInDb?: string;
-    inputType?: string;
-}
-export declare function getValueList<T>(field: FieldRef<T>): T[];
-export declare function getValueList<T>(field: FieldMetadata<T>): T[];
-export declare function getValueList<T>(type: ClassType<T>): T[];
-export declare const storableMember: unique symbol;
-export declare function buildOptions<entityType = any, valueType = any>(options: (FieldOptions<entityType, valueType> | ((options: FieldOptions<entityType, valueType>, remult: Remult) => void))[], remult: Remult): FieldOptions<entityType, valueType>;
-export declare function decorateColumnSettings<valueType>(settings: FieldOptions<any, valueType>, remult: Remult): FieldOptions<any, valueType>;
-export declare class EntityBase {
-    get _(): EntityRefForEntityBase<this>;
-    save(): Promise<this>;
-    assign(values: Partial<Omit<this, keyof EntityBase>>): this;
-    delete(): Promise<void>;
-    isNew(): boolean;
-    get $(): FieldsRefForEntityBase<this>;
-}
-export declare class ControllerBase {
-    protected remult: Remult;
-    constructor(remult?: Remult);
-    assign(values: Partial<Omit<this, keyof EntityBase>>): this;
-    get $(): FieldsRefForEntityBase<this>;
-    get _(): ControllerRefForControllerBase<this>;
-}
-declare class SubscribableImp implements Subscribable {
-    reportChanged(): void;
-    reportObserved(): void;
-    private _subscribers;
-    subscribe(listener: (() => void) | {
-        reportChanged: () => void;
-        reportObserved: () => void;
-    }): Unsubscribe;
-}
-export declare function getEntityMetadata<entityType>(entity: EntityMetadataOverloads<entityType>): EntityMetadata<entityType>;
-export declare function getRepository<entityType>(entity: RepositoryOverloads<entityType>): Repository<entityType>;
-export type EntityMetadataOverloads<entityType> = Repository<entityType> | EntityMetadata<entityType> | ClassType<entityType>;
-export type RepositoryOverloads<entityType> = Repository<entityType> | ClassType<entityType>;
-export {};

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

@@ -1,2 +0,0 @@
-import type { EntityFilter, EntityMetadata } from './remult3';
-export declare function __updateEntityBasedOnWhere<T>(entityDefs: EntityMetadata<T>, where: EntityFilter<T>, r: T): void;

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

@@ -1,6 +0,0 @@
-import type { FieldOptions } from '../column-interfaces';
-import { Remult } from '../context';
-export interface columnInfo {
-    key: string;
-    settings: (remult: Remult) => FieldOptions;
-}

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

@@ -1,28 +0,0 @@
-import type { Remult } from '../context';
-import type { EntityOptions } from '../entity';
-import type { ClassDecoratorContextStub } from './remult3';
-/**Decorates classes that should be used as entities.
- * Receives a key and an array of EntityOptions.
- * @example
- * import  { Entity, Fields } from "remult";
- * @Entity("tasks", {
- *    allowApiCrud: true
- * })
- * export class Task {
- *    @Fields.uuid()
- *    id!: string;
- *    @Fields.string()
- *    title = '';
- *    @Fields.boolean()
- *    completed = false;
- * }
- * @note
- * EntityOptions can be set in two ways:
- * @example
- * // as an object
- * @Entity("tasks",{ allowApiCrud:true })
- * @example
- * // as an arrow function that receives `remult` as a parameter
- * @Entity("tasks", (options,remult) => options.allowApiCrud = true)
- */
-export declare function Entity<entityType>(key: string, ...options: (EntityOptions<entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType> | ((options: EntityOptions<entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType>, remult: Remult) => void))[]): (target: any, info?: ClassDecoratorContextStub<entityType extends new (...args: any) => any ? entityType : never>) => any;

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

@@ -1,9 +0,0 @@
-import type { ClassType } from '../../classType';
-import type { EntityOptionsFactory } from './RepositoryImplementation';
-import type { EntityRef } from './remult3';
-export declare function getEntityRef<entityType>(entity: entityType, throwException?: boolean): EntityRef<entityType>;
-export declare const entityMember: unique symbol;
-export declare const entityInfo: unique symbol;
-export declare const entityInfo_key: unique symbol;
-export declare function getEntitySettings<T>(entity: ClassType<T>, throwError?: boolean): EntityOptionsFactory | undefined;
-export declare function getEntityKey(entity: ClassType<any>): string;

package/esm/src/remult3/relation-loader-types.d.ts

@@ -1,7 +0,0 @@
-import type { ClassType } from '../../classType';
-import type { EntityMetadata, FindOptions } from './remult3';
-export interface RelationLoaderHelper<toEntity> {
-    metadata: EntityMetadata<toEntity>;
-    entityType: ClassType<toEntity>;
-    find(options: FindOptions<toEntity>): Promise<toEntity[]>;
-}

package/esm/src/remult3/relation-loader.d.ts

@@ -1,40 +0,0 @@
-import type { RelationLoaderHelper } from './relation-loader-types';
-import type { FindOptions } from './remult3';
-export declare class RelationLoader {
-    entityLoaders: Map<any, EntityLoader>;
-    promises: any[];
-    load(rel: RelationLoaderHelper<any>, findOptions: FindOptions<any>): Promise<any[]>;
-    constructor();
-    resolveAll(): Promise<void>;
-}
-declare class EntityLoader {
-    private rel;
-    queries: Map<string, QueryVariation>;
-    find(findOptions: FindOptions<any>): Promise<any[]>;
-    constructor(rel: RelationLoaderHelper<any>);
-}
-declare class QueryVariation {
-    private rel;
-    find(findOptions: FindOptions<any>, where: any): Promise<any[]>;
-    constructor(rel: RelationLoaderHelper<any>);
-    resolve(): void;
-    pendingInStatements: Map<string, PendingInStatements>;
-    whereVariations: Map<string, {
-        result: Promise<any[]>;
-    }>;
-}
-declare class PendingInStatements {
-    private rel;
-    private key;
-    private options;
-    resolve(): void;
-    find(where: any): Promise<any[]>;
-    values: Map<any, {
-        value: any;
-        resolve: (value: any[]) => void;
-        reject: (error: any) => void;
-        result: Promise<any[]>;
-    }>;
-    constructor(rel: RelationLoaderHelper<any>, key: string, options: FindOptions<any>);
-}
-export {};

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

@@ -1,4 +0,0 @@
-import type { FieldOptions } from '../column-interfaces';
-import type { RelationInfo } from './remult3';
-export declare const relationInfoMember: unique symbol;
-export declare function getRelationInfo(options: FieldOptions): RelationInfo;