@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/replication-protocol/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * These files contain the replication protocol.
+ * It can be used to replicated RxStorageInstances or RxCollections
+ * or even to do a client(s)-server replication.
+ */
+import type { RxConflictHandler, RxReplicationHandler, RxStorageInstance, RxStorageInstanceReplicationInput, RxStorageInstanceReplicationState } from '../types/index.d.ts';
+export * from './checkpoint.ts';
+export * from './downstream.ts';
+export * from './upstream.ts';
+export * from './meta-instance.ts';
+export * from './conflicts.ts';
+export * from './helper.ts';
+export * from './default-conflict-handler.ts';
+/**
+ * Used in tests to ensure all states are cleaned up
+ * and we have no memory leak.
+ */
+export declare const OPEN_REPLICATION_STATES: Set<RxStorageInstanceReplicationState<any>>;
+export declare function replicateRxStorageInstance<RxDocType>(input: RxStorageInstanceReplicationInput<RxDocType>): RxStorageInstanceReplicationState<RxDocType>;
+export declare function awaitRxStorageReplicationFirstInSync(state: RxStorageInstanceReplicationState<any>): Promise<void>;
+export declare function awaitRxStorageReplicationInSync(replicationState: RxStorageInstanceReplicationState<any>): Promise<[any, any, any]>;
+export declare function awaitRxStorageReplicationIdle(state: RxStorageInstanceReplicationState<any>): Promise<void>;
+export declare function rxStorageInstanceToReplicationHandler<RxDocType, MasterCheckpointType>(instance: RxStorageInstance<RxDocType, any, any, MasterCheckpointType>, conflictHandler: RxConflictHandler<RxDocType>, databaseInstanceToken: string, 
+/**
+ * If set to true,
+ * the _meta.lwt from the pushed documents is kept.
+ * (Used in the migration to ensure checkpoints are still valid)
+ */
+keepMeta?: boolean): RxReplicationHandler<RxDocType, MasterCheckpointType>;
+export declare function cancelRxStorageReplication(replicationState: RxStorageInstanceReplicationState<any>): Promise<void>;

package/dist/types/replication-protocol/meta-instance.d.ts

@@ -0,0 +1,12 @@
+import type { BulkWriteRow, ById, RxDocumentData, RxJsonSchema, RxStorageInstanceReplicationState, RxStorageReplicationMeta, WithDeleted } from '../types/index.d.ts';
+export declare const META_INSTANCE_SCHEMA_TITLE = "RxReplicationProtocolMetaData";
+export declare function getRxReplicationMetaInstanceSchema<RxDocType, CheckpointType>(replicatedDocumentsSchema: RxJsonSchema<RxDocumentData<RxDocType>>, encrypted: boolean): RxJsonSchema<RxDocumentData<RxStorageReplicationMeta<RxDocType, CheckpointType>>>;
+/**
+ * Returns the document states of what the fork instance
+ * assumes to be the latest state on the master instance.
+ */
+export declare function getAssumedMasterState<RxDocType>(state: RxStorageInstanceReplicationState<RxDocType>, docIds: string[]): Promise<ById<{
+    docData: WithDeleted<RxDocType>;
+    metaDocument: RxDocumentData<RxStorageReplicationMeta<RxDocType, any>>;
+}>>;
+export declare function getMetaWriteRow<RxDocType>(state: RxStorageInstanceReplicationState<RxDocType>, newMasterDocState: WithDeleted<RxDocType>, previous?: RxDocumentData<RxStorageReplicationMeta<RxDocType, any>>, isResolvedConflict?: string): Promise<BulkWriteRow<RxStorageReplicationMeta<RxDocType, any>>>;

package/dist/types/replication-protocol/upstream.d.ts

@@ -0,0 +1,10 @@
+import type { RxStorageInstanceReplicationState } from '../types/index.d.ts';
+/**
+ * Writes all document changes from the fork to the master.
+ * The upstream runs on two modes:
+ * - For initial replication, a checkpoint-iteration is used
+ * - For ongoing local writes, we just subscribe to the changeStream of the fork.
+ *   In contrast to the master, the fork can be assumed to never loose connection,
+ *   so we do not have to prepare for missed out events.
+ */
+export declare function startReplicationUpstream<RxDocType, CheckpointType>(state: RxStorageInstanceReplicationState<RxDocType>): Promise<void>;

package/dist/types/rx-change-event.d.ts

@@ -0,0 +1,20 @@
+/**
+ * RxChangeEvents a emitted when something in the database changes
+ * they can be grabbed by the observables of database, collection and document
+ */
+import type { ChangeEvent as EventReduceChangeEvent } from 'event-reduce-js';
+import type { EventBulk, RxChangeEvent, RxChangeEventBulk, RxDocumentData, RxStorageChangeEvent } from './types/index.d.ts';
+export declare function getDocumentDataOfRxChangeEvent<T>(rxChangeEvent: RxStorageChangeEvent<T>): RxDocumentData<T>;
+/**
+ * Might return null which means an
+ * already deleted document got modified but still is deleted.
+ * These kind of events are not relevant for the event-reduce algorithm
+ * and must be filtered out.
+ */
+export declare function rxChangeEventToEventReduceChangeEvent<DocType>(rxChangeEvent: RxStorageChangeEvent<DocType>): EventReduceChangeEvent<DocType> | null;
+/**
+ * Flattens the given events into a single array of events.
+ * Used mostly in tests.
+ */
+export declare function flattenEvents<EventType>(input: EventBulk<EventType, any> | EventBulk<EventType, any>[] | EventType | EventType[]): EventType[];
+export declare function rxChangeEventBulkToRxChangeEvents(eventBulk: RxChangeEventBulk<any>): RxChangeEvent<any>[];

package/dist/types/rx-collection-helper.d.ts

@@ -0,0 +1,41 @@
+import type { HashFunction, InternalStoreDocType, RxAttachmentWriteData, RxCollection, RxDatabase, RxDocumentData, RxStorage, RxStorageInstance, RxStorageInstanceCreationParams } from './types/index.d.ts';
+import type { RxSchema } from './rx-schema.ts';
+import type { RxCollectionBase } from './rx-collection.ts';
+/**
+ * fills in the default data.
+ * This also clones the data.
+ */
+export declare function fillObjectDataBeforeInsert<RxDocType>(schema: RxSchema<RxDocType>, data: Partial<RxDocumentData<RxDocType>> | any): RxDocumentData<RxDocType>;
+/**
+ * Normalizes inline attachment inputs on a document's _attachments.
+ * Accepts an array of { id, type, data } objects (aligned with putAttachment API)
+ * and converts to the internal map format { [id]: { type, data, digest, length } }.
+ * For each entry where data is a Blob and digest is missing,
+ * computes digest via hashFunction and sets length from Blob.size.
+ * Already-complete RxAttachmentWriteData entries are left untouched.
+ */
+export declare function normalizeInlineAttachments(hashFunction: HashFunction, attachments: Array<{
+    id: string;
+    type: string;
+    data: Blob;
+}> | {
+    [attachmentId: string]: any;
+}): Promise<{
+    [attachmentId: string]: RxAttachmentWriteData;
+}>;
+/**
+ * Creates the storage instances that are used internally in the collection
+ */
+export declare function createRxCollectionStorageInstance<RxDocumentType, Internals, InstanceCreationOptions>(rxDatabase: RxDatabase<{}, Internals, InstanceCreationOptions>, storageInstanceCreationParams: RxStorageInstanceCreationParams<RxDocumentType, InstanceCreationOptions>): Promise<RxStorageInstance<RxDocumentType, Internals, InstanceCreationOptions>>;
+/**
+ * Removes the main storage of the collection
+ * and all connected storages like the ones from the replication meta etc.
+ */
+export declare function removeCollectionStorages(storage: RxStorage<any, any>, databaseInternalStorage: RxStorageInstance<InternalStoreDocType<any>, any, any>, databaseInstanceToken: string, databaseName: string, collectionName: string, multiInstance: boolean, password?: string, 
+/**
+ * If no hash function is provided,
+ * we assume that the whole internal store is removed anyway
+ * so we do not have to delete the meta documents.
+ */
+hashFunction?: HashFunction): Promise<void>;
+export declare function ensureRxCollectionIsNotClosed(collection: RxCollection | RxCollectionBase<any, any, any, any, any>): void;

package/dist/types/rx-collection.d.ts

@@ -0,0 +1,185 @@
+import type { RxMigrationState } from './plugins/migration-schema/index.ts';
+import { DocumentCache } from './doc-cache.ts';
+import { QueryCache } from './query-cache.ts';
+import { ChangeEventBuffer } from './change-event-buffer.ts';
+import { Subscription, Observable, Subject } from 'rxjs';
+import type { KeyFunctionMap, RxCollection, RxDatabase, RxQuery, RxDocument, RxDumpCollection, RxDumpCollectionAny, MangoQuery, MangoQueryNoLimit, RxCacheReplacementPolicy, RxStorageWriteError, RxChangeEvent, RxChangeEventInsert, RxChangeEventUpdate, RxChangeEventDelete, RxStorageInstance, CollectionsOfDatabase, RxChangeEventBulk, RxConflictHandler, MaybePromise, CRDTEntry, MangoQuerySelectorAndIndex, MigrationStrategies, WebMCPOptions, WebMCPLogEvent } from './types/index.d.ts';
+import { RxSchema } from './rx-schema.ts';
+import { WrappedRxStorageInstance } from './rx-storage-helper.ts';
+import { IncrementalWriteQueue } from './incremental-write.ts';
+import type { RxPipeline, RxPipelineOptions } from './plugins/pipeline/index.ts';
+declare const HOOKS_WHEN: readonly ["pre", "post"];
+type HookWhenType = typeof HOOKS_WHEN[number];
+declare const HOOKS_KEYS: readonly ["insert", "save", "remove", "create"];
+type HookKeyType = typeof HOOKS_KEYS[number];
+export interface UpsertOptions {
+    /**
+     * When true, existing attachments not present in the upsert data
+     * will be removed. Defaults to false (preserve existing attachments).
+     */
+    deleteExistingAttachments?: boolean;
+}
+export declare const OPEN_COLLECTIONS: Set<RxCollectionBase<any, any, any, {
+    [key: string]: any;
+}, any>>;
+export declare class RxCollectionBase<InstanceCreationOptions, RxDocumentType = {
+    [prop: string]: any;
+}, OrmMethods = {}, StaticMethods = {
+    [key: string]: any;
+}, Reactivity = any> {
+    readonly database: RxDatabase<CollectionsOfDatabase, any, InstanceCreationOptions, Reactivity>;
+    name: string;
+    schema: RxSchema<RxDocumentType>;
+    internalStorageInstance: RxStorageInstance<RxDocumentType, any, InstanceCreationOptions>;
+    instanceCreationOptions: InstanceCreationOptions;
+    migrationStrategies: MigrationStrategies;
+    methods: KeyFunctionMap;
+    attachments: KeyFunctionMap;
+    options: any;
+    cacheReplacementPolicy: RxCacheReplacementPolicy;
+    statics: KeyFunctionMap;
+    conflictHandler: RxConflictHandler<RxDocumentType>;
+    /**
+     * Stores all 'normal' documents
+     */
+    storageInstance: WrappedRxStorageInstance<RxDocumentType, any, InstanceCreationOptions>;
+    readonly timeouts: Set<ReturnType<typeof setTimeout>>;
+    incrementalWriteQueue: IncrementalWriteQueue<RxDocumentType>;
+    /**
+     * Before reads, all these methods are awaited. Used to "block" reads
+     * depending on other processes, like when the RxPipeline is running.
+     */
+    readonly awaitBeforeReads: Set<() => MaybePromise<any>>;
+    constructor(database: RxDatabase<CollectionsOfDatabase, any, InstanceCreationOptions, Reactivity>, name: string, schema: RxSchema<RxDocumentType>, internalStorageInstance: RxStorageInstance<RxDocumentType, any, InstanceCreationOptions>, instanceCreationOptions?: InstanceCreationOptions, migrationStrategies?: MigrationStrategies, methods?: KeyFunctionMap, attachments?: KeyFunctionMap, options?: any, cacheReplacementPolicy?: RxCacheReplacementPolicy, statics?: KeyFunctionMap, conflictHandler?: RxConflictHandler<RxDocumentType>);
+    get insert$(): Observable<RxChangeEventInsert<RxDocumentType>>;
+    get update$(): Observable<RxChangeEventUpdate<RxDocumentType>>;
+    get remove$(): Observable<RxChangeEventDelete<RxDocumentType>>;
+    _incrementalUpsertQueues: Map<string, Promise<any>>;
+    synced: boolean;
+    hooks: {
+        [key in HookKeyType]: {
+            [when in HookWhenType]: {
+                series: Function[];
+                parallel: Function[];
+            };
+        };
+    };
+    _subs: Subscription[];
+    _docCache: DocumentCache<RxDocumentType, OrmMethods>;
+    _queryCache: QueryCache;
+    $: Observable<RxChangeEvent<RxDocumentType>>;
+    checkpoint$: Observable<any>;
+    _changeEventBuffer: ChangeEventBuffer<RxDocumentType>;
+    /**
+     * Internally only use eventBulks$
+     * Do not use .$ or .observable$ because that has to transform
+     * the events which decreases performance.
+     */
+    readonly eventBulks$: Observable<RxChangeEventBulk<any>>;
+    /**
+     * When the collection is closed,
+     * these functions will be called an awaited.
+     * Used to automatically clean up stuff that
+     * belongs to this collection.
+    */
+    onClose: (() => MaybePromise<any>)[];
+    closed: boolean;
+    onRemove: (() => MaybePromise<any>)[];
+    prepare(): Promise<void>;
+    /**
+     * Manually call the cleanup function of the storage.
+     * @link https://rxdb.info/cleanup.html
+     */
+    cleanup(_minimumDeletedTime?: number): Promise<boolean>;
+    migrationNeeded(): Promise<boolean>;
+    getMigrationState(): RxMigrationState;
+    startMigration(batchSize?: number): Promise<void>;
+    migratePromise(batchSize?: number): Promise<any>;
+    insert(json: RxDocumentType | RxDocument): Promise<RxDocument<RxDocumentType, OrmMethods>>;
+    insertIfNotExists(json: RxDocumentType | RxDocument): Promise<RxDocument<RxDocumentType, OrmMethods>>;
+    bulkInsert(docsData: RxDocumentType[]): Promise<{
+        success: RxDocument<RxDocumentType, OrmMethods>[];
+        error: RxStorageWriteError<RxDocumentType>[];
+    }>;
+    bulkRemove(
+    /**
+     * You can either remove the documents by their ids
+     * or by directly providing the RxDocument instances
+     * if you have them already. This improves performance a bit.
+     */
+    idsOrDocs: string[] | RxDocument<RxDocumentType>[]): Promise<{
+        success: RxDocument<RxDocumentType, OrmMethods>[];
+        error: RxStorageWriteError<RxDocumentType>[];
+    }>;
+    /**
+     * same as bulkInsert but overwrites existing document with same primary
+     */
+    bulkUpsert(docsData: Partial<RxDocumentType>[], options?: UpsertOptions): Promise<{
+        success: RxDocument<RxDocumentType, OrmMethods>[];
+        error: RxStorageWriteError<RxDocumentType>[];
+    }>;
+    /**
+     * same as insert but overwrites existing document with same primary
+     */
+    upsert(json: Partial<RxDocumentType>, options?: UpsertOptions): Promise<RxDocument<RxDocumentType, OrmMethods>>;
+    /**
+     * upserts to a RxDocument, uses incrementalModify if document already exists
+     */
+    incrementalUpsert(json: Partial<RxDocumentType>, options?: UpsertOptions): Promise<RxDocument<RxDocumentType, OrmMethods>>;
+    find(queryObj?: MangoQuery<RxDocumentType>): RxQuery<RxDocumentType, RxDocument<RxDocumentType, OrmMethods>[], OrmMethods, Reactivity>;
+    findOne(queryObj?: MangoQueryNoLimit<RxDocumentType> | string): RxQuery<RxDocumentType, RxDocument<RxDocumentType, OrmMethods> | null, OrmMethods, Reactivity>;
+    count(queryObj?: MangoQuerySelectorAndIndex<RxDocumentType>): RxQuery<RxDocumentType, number, OrmMethods, Reactivity>;
+    /**
+     * find a list documents by their primary key
+     * has way better performance then running multiple findOne() or a find() with a complex $or-selected
+     */
+    findByIds(ids: string[]): RxQuery<RxDocumentType, Map<string, RxDocument<RxDocumentType, OrmMethods>>, OrmMethods, Reactivity>;
+    /**
+     * Export collection to a JSON friendly format.
+     */
+    exportJSON(): Promise<RxDumpCollection<RxDocumentType>>;
+    exportJSON(): Promise<RxDumpCollectionAny<RxDocumentType>>;
+    /**
+     * Import the parsed JSON export into the collection.
+     * @param _exportedJSON The previously exported data from the `<collection>.exportJSON()` method.
+     */
+    importJSON(_exportedJSON: RxDumpCollectionAny<RxDocumentType>): Promise<void>;
+    registerWebMCP(_options?: WebMCPOptions): {
+        error$: Subject<Error>;
+        log$: Subject<WebMCPLogEvent>;
+    };
+    insertCRDT(_updateObj: CRDTEntry<any> | CRDTEntry<any>[]): RxDocument<RxDocumentType, OrmMethods>;
+    addPipeline(_options: RxPipelineOptions<RxDocumentType>): Promise<RxPipeline<RxDocumentType>>;
+    /**
+     * HOOKS
+     */
+    addHook(when: HookWhenType, key: HookKeyType, fun: any, parallel?: boolean): void;
+    getHooks(when: HookWhenType, key: HookKeyType): {
+        series: Function[];
+        parallel: Function[];
+    };
+    hasHooks(when: HookWhenType, key: HookKeyType): boolean;
+    _runHooks(when: HookWhenType, key: HookKeyType, data: any, instance?: any): Promise<any>;
+    /**
+     * does the same as ._runHooks() but with non-async-functions
+     */
+    _runHooksSync(when: HookWhenType, key: HookKeyType, data: any, instance: any): void;
+    /**
+     * Returns a promise that resolves after the given time.
+     * Ensures that is properly cleans up when the collection is closed
+     * so that no running timeouts prevent the exit of the JavaScript process.
+     */
+    promiseWait(time: number): Promise<void>;
+    close(): Promise<boolean>;
+    /**
+     * remove all data of the collection
+     */
+    remove(): Promise<any>;
+    get asRxCollection(): RxCollection<RxDocumentType, OrmMethods, StaticMethods, any, Reactivity>;
+}
+/**
+ * creates and prepares a new collection
+ */
+export declare function createRxCollection({ database, name, schema, instanceCreationOptions, migrationStrategies, autoMigrate, statics, methods, attachments, options, localDocuments, cacheReplacementPolicy, conflictHandler, storageInstance }: any): Promise<RxCollection>;
+export declare function isRxCollection(obj: any): boolean;
+export {};

package/dist/types/rx-database-internal-store.d.ts

@@ -0,0 +1,37 @@
+import type { CollectionsOfDatabase, InternalStoreCollectionDocType, InternalStoreDocType, InternalStoreStorageTokenDocType, RxCollection, RxDatabase, RxDocumentData, RxJsonSchema, RxStorageInstance } from './types/index.d.ts';
+export declare const INTERNAL_CONTEXT_COLLECTION = "collection";
+export declare const INTERNAL_CONTEXT_STORAGE_TOKEN = "storage-token";
+export declare const INTERNAL_CONTEXT_MIGRATION_STATUS = "rx-migration-status";
+export declare const INTERNAL_CONTEXT_PIPELINE_CHECKPOINT = "rx-pipeline-checkpoint";
+/**
+ * Do not change the title,
+ * we have to flag the internal schema so that
+ * some RxStorage implementations are able
+ * to detect if the created RxStorageInstance
+ * is from the internals or not,
+ * to do some optimizations in some cases.
+ */
+export declare const INTERNAL_STORE_SCHEMA_TITLE = "RxInternalDocument";
+export declare const INTERNAL_STORE_SCHEMA: RxJsonSchema<RxDocumentData<InternalStoreDocType<any>>>;
+export declare function getPrimaryKeyOfInternalDocument(key: string, context: string): string;
+/**
+ * Returns all internal documents
+ * with context 'collection'
+ */
+export declare function getAllCollectionDocuments(storageInstance: RxStorageInstance<InternalStoreDocType<any>, any, any>): Promise<RxDocumentData<InternalStoreCollectionDocType>[]>;
+/**
+ * to not confuse multiInstance-messages with other databases that have the same
+ * name and adapter, but do not share state with this one (for example in-memory-instances),
+ * we set a storage-token and use it in the broadcast-channel
+ */
+export declare const STORAGE_TOKEN_DOCUMENT_KEY = "storageToken";
+export declare const STORAGE_TOKEN_DOCUMENT_ID: string;
+export declare function ensureStorageTokenDocumentExists<Collections extends CollectionsOfDatabase = any>(rxDatabase: RxDatabase<Collections>): Promise<RxDocumentData<InternalStoreStorageTokenDocType>>;
+export declare function isDatabaseStateVersionCompatibleWithDatabaseCode(databaseStateVersion: string, codeVersion: string): boolean;
+export declare function addConnectedStorageToCollection(collection: RxCollection<any, unknown, unknown, unknown>, storageCollectionName: string, schema: RxJsonSchema<any>): Promise<void>;
+export declare function removeConnectedStorageFromCollection(collection: RxCollection<any, unknown, unknown, unknown>, storageCollectionName: string, schema: RxJsonSchema<any>): Promise<void>;
+/**
+ * returns the primary for a given collection-data
+ * used in the internal store of a RxDatabase
+ */
+export declare function _collectionNamePrimary(name: string, schema: RxJsonSchema<any>): string;

package/dist/types/rx-database.d.ts

@@ -0,0 +1,213 @@
+import { IdleQueue } from 'custom-idle-queue';
+import type { LeaderElector } from 'broadcast-channel';
+import { ObliviousSet } from 'oblivious-set';
+import type { CollectionsOfDatabase, RxDatabase, RxCollectionCreator, RxCollection, RxDumpDatabase, RxDumpDatabaseAny, BackupOptions, RxStorage, RxStorageInstance, RxChangeEvent, RxDatabaseCreator, RxChangeEventBulk, RxDocumentData, RxCleanupPolicy, InternalStoreDocType, InternalStoreStorageTokenDocType, RxTypeError, RxError, HashFunction, MaybePromise, RxState, RxCollectionEvent, WebMCPOptions, WebMCPLogEvent } from './types/index.d.ts';
+import { Subject, Subscription, Observable } from 'rxjs';
+import { WrappedRxStorageInstance } from './rx-storage-helper.ts';
+import type { RxBackupState } from './plugins/backup/index.ts';
+import type { RxMigrationState } from './plugins/migration-schema/index.ts';
+import type { RxReactivityFactory } from './types/plugins/reactivity.d.ts';
+export declare class RxDatabaseBase<Internals, InstanceCreationOptions, Collections = CollectionsOfDatabase, Reactivity = unknown> {
+    readonly name: string;
+    /**
+     * Uniquely identifies the instance
+     * of this RxDatabase.
+     */
+    readonly token: string;
+    readonly storage: RxStorage<Internals, InstanceCreationOptions>;
+    readonly instanceCreationOptions: InstanceCreationOptions;
+    readonly password: any;
+    readonly multiInstance: boolean;
+    readonly eventReduce: boolean;
+    options: any;
+    /**
+     * Stores information documents about the collections of the database
+     */
+    readonly internalStore: RxStorageInstance<InternalStoreDocType, Internals, InstanceCreationOptions>;
+    readonly hashFunction: HashFunction;
+    readonly cleanupPolicy?: Partial<RxCleanupPolicy> | undefined;
+    readonly allowSlowCount?: boolean | undefined;
+    readonly reactivity?: RxReactivityFactory<any> | undefined;
+    readonly onClosed?: (() => void) | undefined;
+    readonly idleQueue: IdleQueue;
+    readonly rxdbVersion = "17.0.0-beta.17";
+    /**
+     * Contains all known non-closed storage instances
+     * that belong to this database.
+     * Used in plugins and unit tests.
+     */
+    readonly storageInstances: Set<WrappedRxStorageInstance<any, Internals, InstanceCreationOptions>>;
+    constructor(name: string, 
+    /**
+     * Uniquely identifies the instance
+     * of this RxDatabase.
+     */
+    token: string, storage: RxStorage<Internals, InstanceCreationOptions>, instanceCreationOptions: InstanceCreationOptions, password: any, multiInstance: boolean, eventReduce: boolean | undefined, options: any | undefined, 
+    /**
+     * Stores information documents about the collections of the database
+     */
+    internalStore: RxStorageInstance<InternalStoreDocType, Internals, InstanceCreationOptions>, hashFunction: HashFunction, cleanupPolicy?: Partial<RxCleanupPolicy> | undefined, allowSlowCount?: boolean | undefined, reactivity?: RxReactivityFactory<any> | undefined, onClosed?: (() => void) | undefined);
+    get $(): Observable<RxChangeEvent<any>>;
+    /**
+     * Emits events whenever a JavaScript instance
+     * of RxCollection is added or removed on the RxDatabase instance.
+     * Does not emit anything across browser-tabs!
+     */
+    get collections$(): Observable<RxCollectionEvent>;
+    getReactivityFactory(): RxReactivityFactory<Reactivity>;
+    _subs: Subscription[];
+    /**
+     * Because having unhandled exceptions would fail,
+     * we have to store the async errors of the constructor here
+     * so we can throw them later.
+     */
+    startupErrors: (RxError | RxTypeError)[];
+    /**
+     * When the database is closed,
+     * these functions will be called an awaited.
+     * Used to automatically clean up stuff that
+     * belongs to this collection.
+     */
+    onClose: (() => MaybePromise<any>)[];
+    closed: boolean;
+    collections: Collections;
+    states: {
+        [name: string]: RxState<any, Reactivity>;
+    };
+    /**
+     * Support for `using` / `await using` (ECMAScript explicit resource management).
+     * This allows: `await using db = await createRxDatabase(...)`
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+    /**
+     * Internally only use eventBulks$
+     * Do not use .$ or .observable$ because that has to transform
+     * the events which decreases performance.
+     */
+    readonly eventBulks$: Subject<RxChangeEventBulk<any>>;
+    private closePromise;
+    collectionsSubject$: Subject<RxCollectionEvent>;
+    private observable$;
+    /**
+     * Unique token that is stored with the data.
+     * Used to detect if the dataset has been deleted
+     * and if two RxDatabase instances work on the same dataset or not.
+     *
+     * Because reading and writing the storageToken runs in the hot path
+     * of database creation, we do not await the storageWrites but instead
+     * work with the promise when we need the value.
+     */
+    storageToken: Promise<string>;
+    /**
+     * Stores the whole state of the internal storage token document.
+     * We need this in some plugins.
+     */
+    storageTokenDocument: Promise<RxDocumentData<InternalStoreStorageTokenDocType>>;
+    /**
+     * Contains the ids of all event bulks that have been emitted
+     * by the database.
+     * Used to detect duplicates that come in again via BroadcastChannel
+     * or other streams.
+     * In the past we tried to remove this and to ensure
+     * all storages only emit the same event bulks only once
+     * but it turns out this is just not possible for all storages.
+     * JavaScript processes, workers and browser tabs can be closed and started at any time
+     * which can cause cases where it is not possible to know if an event bulk has been emitted already.
+     */
+    emittedEventBulkIds: ObliviousSet<string>;
+    /**
+     * This is the main handle-point for all change events
+     * ChangeEvents created by this instance go:
+     * RxDocument -> RxCollection -> RxDatabase.$emit -> MultiInstance
+     * ChangeEvents created by other instances go:
+     * MultiInstance -> RxDatabase.$emit -> RxCollection -> RxDatabase
+     */
+    $emit(changeEventBulk: RxChangeEventBulk<any>): void;
+    /**
+     * removes the collection-doc from the internalStore
+     */
+    removeCollectionDoc(name: string, schema: any): Promise<void>;
+    /**
+     * creates multiple RxCollections at once
+     * to be much faster by saving db txs and doing stuff in bulk-operations
+     * This function is not called often, but mostly in the critical path at the initial page load
+     * So it must be as fast as possible.
+     */
+    addCollections<CreatedCollections = Partial<Collections>>(collectionCreators: {
+        [key in keyof CreatedCollections]: RxCollectionCreator<any>;
+    }): Promise<{
+        [key in keyof CreatedCollections]: RxCollection<any, {}, {}, {}, Reactivity>;
+    }>;
+    /**
+     * runs the given function between idleQueue-locking
+     */
+    lockedRun<T>(fn: (...args: any[]) => T): T extends Promise<any> ? T : Promise<T>;
+    requestIdlePromise(): Promise<void>;
+    /**
+     * Export database to a JSON friendly format.
+     */
+    exportJSON(_collections?: string[]): Promise<RxDumpDatabase<Collections>>;
+    exportJSON(_collections?: string[]): Promise<RxDumpDatabaseAny<Collections>>;
+    addState<T = any>(_name?: string): Promise<RxState<T, Reactivity>>;
+    /**
+     * Import the parsed JSON export into the collection.
+     * @param _exportedJSON The previously exported data from the `<db>.exportJSON()` method.
+     * @note When an interface is loaded in this collection all base properties of the type are typed as `any`
+     * since data could be encrypted.
+     */
+    importJSON(_exportedJSON: RxDumpDatabaseAny<Collections>): Promise<void>;
+    backup(_options: BackupOptions): RxBackupState;
+    leaderElector(): LeaderElector;
+    isLeader(): boolean;
+    /**
+     * returns a promise which resolves when the instance becomes leader
+     */
+    waitForLeadership(): Promise<boolean>;
+    migrationStates(): Observable<RxMigrationState[]>;
+    /**
+     * closes the database-instance and all collections
+     */
+    close(): Promise<boolean>;
+    /**
+     * deletes the database and its stored data.
+     * Returns the names of all removed collections.
+     */
+    remove(): Promise<string[]>;
+    get asRxDatabase(): RxDatabase<{}, Internals, InstanceCreationOptions, Reactivity>;
+    registerWebMCP(_options?: WebMCPOptions): {
+        error$: Subject<Error>;
+        log$: Subject<WebMCPLogEvent>;
+    };
+}
+/**
+ * Creates the storage instances that are used internally in the database
+ * to store schemas and other configuration stuff.
+ */
+export declare function createRxDatabaseStorageInstance<Internals, InstanceCreationOptions>(databaseInstanceToken: string, storage: RxStorage<Internals, InstanceCreationOptions>, databaseName: string, options: InstanceCreationOptions, multiInstance: boolean, password?: string): Promise<RxStorageInstance<InternalStoreDocType, Internals, InstanceCreationOptions>>;
+export declare function createRxDatabase<Collections = {
+    [key: string]: RxCollection;
+}, Internals = any, InstanceCreationOptions = any, Reactivity = unknown>({ storage, instanceCreationOptions, name, password, multiInstance, eventReduce, ignoreDuplicate, options, cleanupPolicy, closeDuplicates, allowSlowCount, localDocuments, hashFunction, reactivity }: RxDatabaseCreator<Internals, InstanceCreationOptions, Reactivity>): Promise<RxDatabase<Collections, Internals, InstanceCreationOptions, Reactivity>>;
+/**
+ * Removes the database and all its known data
+ * with all known collections and all internal meta data.
+ *
+ * Returns the names of the removed collections.
+ */
+export declare function removeRxDatabase(databaseName: string, storage: RxStorage<any, any>, multiInstance?: boolean, password?: string): Promise<string[]>;
+export declare function isRxDatabase(obj: any): obj is RxDatabaseBase<any, any, any, any>;
+export declare function dbCount(): number;
+/**
+ * Returns true if the given RxDatabase was the first
+ * instance that was created on the storage with this name.
+ *
+ * Can be used for some optimizations because on the first instantiation,
+ * we can assume that no data was written before.
+ */
+export declare function isRxDatabaseFirstTimeInstantiated(database: RxDatabase): Promise<boolean>;
+/**
+ * For better performance some tasks run async
+ * and are awaited later.
+ * But we still have to ensure that there have been no errors
+ * on database creation.
+ */
+export declare function ensureNoStartupErrors(rxDatabase: RxDatabaseBase<any, any, any, any>): Promise<void>;

package/dist/types/rx-document-prototype-merge.d.ts

@@ -0,0 +1,24 @@
+/**
+ * For the ORM capabilities,
+ * we have to merge the document prototype
+ * with the ORM functions and the data
+ * We do this iterating over the properties and
+ * adding them to a new object.
+ * In the future we should do this by chaining the __proto__ objects
+ */
+import type { RxCollection, RxDocument, RxDocumentData } from './types/index.d.ts';
+export declare function getDocumentPrototype(rxCollection: RxCollection): any;
+export declare function getRxDocumentConstructor<RxDocType, ORM>(rxCollection: RxCollection<RxDocType, ORM>): any;
+/**
+ * Create a RxDocument-instance from the jsonData
+ * and the prototype merge.
+ * You should never call this method directly,
+ * instead you should get the document from collection._docCache.getCachedRxDocument().
+ */
+export declare function createNewRxDocument<RxDocType, ORM, Reactivity>(rxCollection: RxCollection<RxDocType, ORM, {}, {}, Reactivity>, documentConstructor: any, docData: RxDocumentData<RxDocType>): RxDocument<RxDocType, ORM, Reactivity>;
+/**
+ * returns the prototype-object
+ * that contains the orm-methods,
+ * used in the proto-merge
+ */
+export declare function getDocumentOrmPrototype(rxCollection: RxCollection): any;