@connecttomahdi/rxdb 17.0.0-beta.17

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

@@ -0,0 +1,111 @@
+/**
+ * Helper functions for accessing the RxStorage instances.
+ */
+import type { BulkWriteRow, BulkWriteRowProcessed, CategorizeBulkWriteRowsOutput, RxAttachmentData, RxAttachmentWriteData, RxCollection, RxDatabase, RxDocumentData, RxDocumentWriteData, RxJsonSchema, RxStorageWriteError, RxStorageInstance, RxStorageInstanceCreationParams, StringKeys, RxStorage, FilledMangoQuery, RxStorageBulkWriteResponse } from './types/index.d.ts';
+import { Observable } from 'rxjs';
+export declare const INTERNAL_STORAGE_NAME = "_rxdb_internal";
+export declare const RX_DATABASE_LOCAL_DOCS_STORAGE_NAME = "rxdatabase_storage_local";
+export declare function getSingleDocument<RxDocType>(storageInstance: RxStorageInstance<RxDocType, any, any>, documentId: string): Promise<RxDocumentData<RxDocType> | undefined>;
+/**
+ * Writes a single document,
+ * throws RxStorageBulkWriteError on failure
+ */
+export declare function writeSingle<RxDocType>(instance: RxStorageInstance<RxDocType, any, any>, writeRow: BulkWriteRow<RxDocType>, context: string): Promise<RxDocumentData<RxDocType>>;
+/**
+ * Observe the plain document data of a single document.
+ * Do not forget to unsubscribe.
+ */
+export declare function observeSingle<RxDocType>(storageInstance: RxStorageInstance<RxDocType, any, any>, documentId: string): Observable<RxDocumentData<RxDocType>>;
+/**
+ * Checkpoints must be stackable over another.
+ * This is required form some RxStorage implementations
+ * like the sharding plugin, where a checkpoint only represents
+ * the document state from some, but not all shards.
+ */
+export declare function stackCheckpoints<CheckpointType>(checkpoints: (CheckpointType | undefined)[]): CheckpointType;
+export declare function throwIfIsStorageWriteError<RxDocType>(collection: RxCollection<RxDocType, any, any>, documentId: string, writeData: RxDocumentWriteData<RxDocType> | RxDocType, error: RxStorageWriteError<RxDocType> | undefined): void;
+/**
+ * Analyzes a list of BulkWriteRows and determines
+ * which documents must be inserted, updated or deleted
+ * and which events must be emitted and which documents cause a conflict
+ * and must not be written.
+ * Used as helper inside of some RxStorage implementations.
+ * @hotPath The performance of this function is critical
+ */
+export declare function categorizeBulkWriteRows<RxDocType>(storageInstance: RxStorageInstance<any, any, any>, primaryPath: StringKeys<RxDocType>, 
+/**
+ * Current state of the documents
+ * inside of the storage. Used to determine
+ * which writes cause conflicts.
+ * This must be a Map for better performance.
+ */
+docsInDb: Map<RxDocumentData<RxDocType>[StringKeys<RxDocType>] | string, RxDocumentData<RxDocType>>, 
+/**
+ * The write rows that are passed to
+ * RxStorageInstance().bulkWrite().
+ */
+bulkWriteRows: BulkWriteRow<RxDocType>[], context: string, 
+/**
+ * Used by some storages for better performance.
+ * For example when get-by-id and insert/update can run in parallel.
+ */
+onInsert?: (docData: RxDocumentData<RxDocType>) => void, onUpdate?: (docData: RxDocumentData<RxDocType>) => void): CategorizeBulkWriteRowsOutput<RxDocType>;
+export declare function stripAttachmentsDataFromRow<RxDocType>(writeRow: BulkWriteRow<RxDocType>): BulkWriteRowProcessed<RxDocType>;
+/**
+ * Used in custom RxStorage implementations.
+ */
+export declare function attachmentWriteDataToNormalData(writeData: RxAttachmentData | RxAttachmentWriteData): RxAttachmentData;
+export declare function stripAttachmentsDataFromDocument<RxDocType>(doc: RxDocumentWriteData<RxDocType>): RxDocumentData<RxDocType>;
+/**
+ * Flat clone the document data
+ * and also the _meta field.
+ * Used many times when we want to change the meta
+ * during replication etc.
+ */
+export declare function flatCloneDocWithMeta<RxDocType>(doc: RxDocumentData<RxDocType>): RxDocumentData<RxDocType>;
+export type WrappedRxStorageInstance<RxDocumentType, Internals, InstanceCreationOptions> = RxStorageInstance<RxDocumentType, any, InstanceCreationOptions> & {
+    originalStorageInstance: RxStorageInstance<RxDocumentType, Internals, InstanceCreationOptions>;
+};
+/**
+ * Wraps the normal storageInstance of a RxCollection
+ * to ensure that all access is properly using the hooks
+ * and other data transformations and also ensure that database.lockedRun()
+ * is used properly.
+ */
+export declare function getWrappedStorageInstance<RxDocType, Internals, InstanceCreationOptions, CheckpointType>(database: RxDatabase<{}, Internals, InstanceCreationOptions, any>, storageInstance: RxStorageInstance<RxDocType, Internals, InstanceCreationOptions, CheckpointType>, 
+/**
+ * The original RxJsonSchema
+ * before it was mutated by hooks.
+ */
+rxJsonSchema: RxJsonSchema<RxDocumentData<RxDocType>>): WrappedRxStorageInstance<RxDocType, Internals, InstanceCreationOptions>;
+/**
+ * Each RxStorage implementation should
+ * run this method at the first step of createStorageInstance()
+ * to ensure that the configuration is correct.
+ */
+export declare function ensureRxStorageInstanceParamsAreCorrect(params: RxStorageInstanceCreationParams<any, any>): void;
+export declare function hasEncryption(jsonSchema: RxJsonSchema<any>): boolean;
+export declare function getChangedDocumentsSinceQuery<RxDocType, CheckpointType>(storageInstance: RxStorageInstance<RxDocType, any, any, CheckpointType>, limit: number, checkpoint?: CheckpointType): FilledMangoQuery<RxDocType>;
+export declare function getChangedDocumentsSince<RxDocType, CheckpointType>(storageInstance: RxStorageInstance<RxDocType, any, any, CheckpointType>, limit: number, checkpoint?: CheckpointType): Promise<{
+    documents: RxDocumentData<RxDocType>[];
+    /**
+     * The checkpoint contains data so that another
+     * call to getChangedDocumentsSince() will continue
+     * from exactly the last document that was returned before.
+     */
+    checkpoint: CheckpointType;
+}>;
+/**
+ * For better performance, this is done only when accessed
+ * because most of the time we do not need the results, only the errors.
+ */
+export declare function getWrittenDocumentsFromBulkWriteResponse<RxDocType>(primaryPath: string, writeRows: BulkWriteRow<RxDocType>[], response: RxStorageBulkWriteResponse<RxDocType>, reInsertIds?: Set<string>): RxDocumentData<RxDocType>[];
+/**
+ * Wraps the storage and simluates
+ * delays. Mostly used in tests.
+ */
+export declare function randomDelayStorage<Internals, InstanceCreationOptions>(input: {
+    storage: RxStorage<Internals, InstanceCreationOptions>;
+    delayTimeBefore: () => number;
+    delayTimeAfter: () => number;
+}): RxStorage<Internals, InstanceCreationOptions>;

package/dist/types/rx-storage-multiinstance.d.ts

@@ -0,0 +1,51 @@
+/**
+ * When a persistent RxStorage is used in more the one JavaScript process,
+ * the even stream of the changestream() function must be broadcasted to the other
+ * RxStorageInstances of the same databaseName+collectionName.
+ *
+ * In the past this was done by RxDB but it makes more sense to do this
+ * at the RxStorage level so that the broadcasting etc can all happen inside of a WebWorker
+ * and not on the main thread.
+ * Also it makes it less complex to stack up different RxStorages onto each other
+ * like what we do with the in-memory plugin.
+ *
+ * This is intended to be used inside of createStorageInstance() of a storage.
+ * Do not use this if the storage anyway broadcasts the events like when using MongoDB
+ * or in the future W3C might introduce a way to listen to IndexedDB changes.
+ */
+import type { EventBulk, RxStorageInstance, RxStorageInstanceCreationParams } from './types/index.d.ts';
+import { BroadcastChannel } from 'broadcast-channel';
+/**
+ * The broadcast-channel is reused by the databaseInstanceToken.
+ * This is required so that it is easy to simulate multi-tab usage
+ * in the test where different instances of the same RxDatabase must
+ * have different broadcast channels.
+ * But also it ensures that for each RxDatabase we only create a single
+ * broadcast channel that can even be reused in the leader election plugin.
+ */
+export declare const BROADCAST_CHANNEL_BY_TOKEN: Map<string, {
+    bc: BroadcastChannel<RxStorageMultiInstanceBroadcastType>;
+    /**
+     * Contains all context objects that currently use the channel.
+     * If this becomes empty, we can close the channel
+     */
+    refs: Set<any>;
+}>;
+export type RxStorageMultiInstanceBroadcastType = {
+    storageName: string;
+    collectionName: string;
+    /**
+     * collection.schema.version
+     */
+    version: number;
+    databaseName: string;
+    eventBulk: EventBulk<any, any>;
+};
+export declare function getBroadcastChannelReference(storageName: string, databaseInstanceToken: string, databaseName: string, refObject: any): BroadcastChannel<RxStorageMultiInstanceBroadcastType>;
+export declare function removeBroadcastChannelReference(databaseInstanceToken: string, refObject: any): Promise<void> | undefined;
+export declare function addRxStorageMultiInstanceSupport<RxDocType>(storageName: string, instanceCreationParams: RxStorageInstanceCreationParams<RxDocType, any>, instance: RxStorageInstance<RxDocType, any, any>, 
+/**
+ * If provided, that channel will be used
+ * instead of an own one.
+ */
+providedBroadcastChannel?: BroadcastChannel<any>): void;

package/dist/types/types/conflict-handling.d.ts

@@ -0,0 +1,48 @@
+import type { WithDeleted } from './rx-storage.d.ts';
+
+/**
+ * Notice that the conflict handler input/output
+ * does not work on RxDocumentData<RxDocType>, but only on WithDeleted<RxDocType>.
+ * This is because the _meta attributes are meant for the local storing of document data, they not replicated
+ * and therefore cannot be used to resolve conflicts.
+ */
+export type RxConflictHandlerInput<RxDocType> = {
+    assumedMasterState?: WithDeleted<RxDocType>;
+    realMasterState: WithDeleted<RxDocType>;
+    newDocumentState: WithDeleted<RxDocType>;
+};
+
+/**
+ * The conflict handler either returns:
+ * - The resolved new document state
+ * - A flag to identify the given 'realMasterState' and 'newDocumentState'
+ *   as being exactly equal, so no conflict has to be resolved.
+ */
+export type RxConflictHandlerOutput<RxDocType> = {
+    isEqual: false;
+    documentData: WithDeleted<RxDocType>;
+} | {
+    isEqual: true;
+};
+
+export type RxConflictHandlerOld<RxDocType> = (
+    i: RxConflictHandlerInput<RxDocType>,
+    context: string
+) => Promise<RxConflictHandlerOutput<RxDocType>>;
+
+
+export type RxConflictHandler<RxDocType> = {
+    /**
+     * This must be non-async
+     * because it will be called very often and must be fast.
+     */
+    isEqual: (
+        a: WithDeleted<RxDocType>,
+        b: WithDeleted<RxDocType>,
+        context: string
+    ) => boolean;
+    resolve: (
+        i: RxConflictHandlerInput<RxDocType>,
+        context: string
+    ) => Promise<WithDeleted<RxDocType>>;
+};

package/dist/types/types/couchdb.d.ts

@@ -0,0 +1,293 @@
+import type {
+    MangoQuery,
+    MangoQuerySelector,
+    MangoQuerySortPart
+} from './rx-query.d.ts';
+import type { BulkWriteRow } from './rx-storage.d.ts';
+
+/**
+ * This file contains types that are CouchDB specific
+ */
+
+export interface CouchReplicationOptions {
+    live?: boolean;
+    retry?: boolean;
+    filter?: Function;
+    doc_ids?: string[];
+    query_params?: any;
+    view?: any;
+    since?: number | 'now';
+    heartbeat?: number;
+    timeout?: number;
+    batch_size?: number;
+    batches_limit?: number;
+    back_off_function?: Function;
+    checkpoint?: false | 'source' | 'target';
+    include_docs?: boolean;
+    limit?: number;
+}
+
+export interface CouchChangesOptionsBase {
+    include_docs?: boolean;
+    conflicts?: boolean;
+    attachments?: boolean;
+    binary?: boolean;
+    descending?: boolean;
+    since?: any;
+    limit?: number;
+    timeout?: any;
+    heartbeat?: number | boolean;
+    filter?: any;
+    doc_ids?: string | string[];
+    query_param?: any;
+    view?: any;
+    return_docs?: boolean;
+    batch_size?: number;
+    style?: string;
+}
+
+export interface CouchChangesOptionsLive extends CouchChangesOptionsBase {
+    live: true;
+}
+
+export interface CouchChangesOptionsNonLive extends CouchChangesOptionsBase {
+    live: false;
+}
+interface CouchChangesOnChangeEvent {
+    on: (eventName: string, handler: Function) => void;
+    off: (eventName: string, handler: Function) => void;
+    cancel(): void;
+}
+
+export type CouchWriteError = {
+    /**
+      * status code from couchdb
+      * 409 for 'conflict'
+    */
+    status: number;
+    error: true;
+    /**
+     * primary key value of the errored document
+     */
+    id: string;
+};
+
+/**
+ * possible couch-settings
+ * @link https://couchdb.com/api.html#create_database
+ */
+export interface CouchSettings {
+    auto_compaction?: boolean;
+    revs_limit?: number;
+    ajax?: any;
+    fetch?: any;
+    auth?: any;
+    skip_setup?: boolean;
+    storage?: any;
+    size?: number;
+    location?: string;
+    iosDatabaseLocation?: string;
+}
+
+/**
+ * options for couch.allDocs()
+ * @link https://couchdb.com/api.html#batch_fetch
+ */
+export type CouchAllDocsOptions = {
+    include_docs?: boolean;
+    conflicts?: boolean;
+    attachments?: boolean;
+    binary?: boolean;
+    startkey?: string;
+    endkey?: string;
+    inclusive_end?: boolean;
+    limit?: number;
+    skip?: number;
+    descending?: boolean;
+    key?: string;
+    keys?: string[];
+    update_seq?: string;
+
+    // undocument but needed
+    revs?: boolean;
+    deleted?: 'ok';
+};
+
+export type CouchSyncHandlerEvents = 'change' | 'paused' | 'active' | 'error' | 'complete';
+export type CouchSyncHandler = {
+    on(ev: CouchSyncHandlerEvents, fn: (el: any) => void): void;
+    off(ev: CouchSyncHandlerEvents, fn: any): void;
+    cancel(): void;
+};
+
+export type CouchChangeRow = {
+    id: string;
+    seq: number;
+    deleted?: true;
+    changes: {
+        rev: 'string';
+    }[];
+    /**
+     * only if include_docs === true
+     */
+    doc?: CouchChangeDoc;
+};
+
+export type CouchAttachmentMeta = {
+    digest: string;
+    content_type: string;
+    length: number;
+    stub: boolean;
+
+    /**
+     * 'revpos indicates the generation number (numeric prefix in the revID) at which the attachment was last altered'
+     *  @link https://github.com/couchbase/couchbase-lite-ios/issues/1200#issuecomment-206444554
+     */
+    revpos: number;
+};
+
+export type CouchAttachmentWithData = CouchAttachmentMeta & {
+    /**
+     * Base64 string with the data
+     * or directly a buffer
+     */
+    data: Blob;
+    type: string;
+    /**
+     * If set, must be false
+     * because we have the full data and not only a stub.
+     */
+    stub?: false;
+};
+
+export type CouchChangeDoc = {
+    _id: string;
+    _rev: string;
+    /**
+     * True if the document is deleted.
+     */
+    _deleted?: boolean;
+    _attachments: {
+        [attachmentId: string]: CouchAttachmentMeta;
+    };
+};
+
+export type WithAttachments<Data> = Data & {
+    /**
+     * Intentional optional,
+     * if the document has no attachments,
+     * we do NOT have an empty object.
+     */
+    _attachments?: {
+        [attachmentId: string]: CouchAttachmentMeta;
+    };
+};
+export type WithAttachmentsData<Data> = Data & {
+    /**
+     * Intentional optional,
+     * if the document has no attachments,
+     * we do NOT have an empty object.
+     */
+    _attachments?: {
+        [attachmentId: string]: CouchAttachmentWithData;
+    };
+};
+
+
+export type WithCouchMeta<Data> = Data & {
+    _rev: string;
+    _attachments?: {
+        [attachmentId: string]: CouchAttachmentMeta;
+    };
+    _deleted?: boolean;
+};
+
+export type CouchdbChangesResult = {
+    results: CouchChangeRow[];
+    last_seq: number;
+};
+
+declare type Debug = {
+    enable(what: string): void;
+    disable(): void;
+};
+
+export type CouchDbSorting = (string | string[] | { [k: string]: 'asc' | 'desc' | 1 | -1; })[];
+
+// this is not equal to the standard MangoQuery
+// because of different sorting
+export type CouchdbQuery = MangoQuery & {
+    sort?: CouchDbSorting;
+};
+
+export type CouchBulkDocResultRow = {
+    ok: boolean;
+    id: string;
+    rev: string;
+
+    error?: 'conflict';
+    reason?: string;
+};
+
+export type CouchCheckpoint = {
+    sequence: number;
+};
+
+export type CouchBulkDocOptions = {
+    new_edits?: boolean;
+
+    // custom options for RxDB
+    isDeeper?: boolean;
+    custom?: {
+        primaryPath: string;
+        writeRowById: Map<string, BulkWriteRow<any>>;
+        insertDocsById: Map<string, any>;
+        previousDocsInDb: Map<string, any>;
+        context: string;
+    };
+};
+
+export type CouchMangoQuery<DocType> = MangoQuery<DocType> & {
+    index: undefined;
+    use_index?: string;
+};
+
+export type ExplainedCouchQuery<DocType> = {
+    dbname: string;
+    index: {
+        ddoc: string | null;
+        name: string; // 'idx-rxdb-index-age,_id'
+        type: 'json';
+        def: {
+            fields: MangoQuerySortPart<DocType>[];
+        };
+    };
+    selector: MangoQuerySelector<DocType>;
+    range: {
+        start_key: any[];
+        end_key: any[];
+    };
+    opts: {
+        use_index: string[];
+        bookmark: string;
+        sort: MangoQuerySortPart<DocType>[];
+        conflicts: boolean;
+        r: any[];
+    };
+    skip: number;
+};
+
+export type CouchAllDocsResponse = {
+    offset: number;
+    rows: {
+        id: string;
+        doc: any;
+        key: string;
+        value: {
+            rev: string;
+            deleted?: boolean;
+        };
+        error?: 'not_found' | string;
+    }[];
+    total_rows: number;
+};

package/dist/types/types/index.d.ts

@@ -0,0 +1,32 @@
+export type * from './couchdb.d.ts';
+export type * from './rx-attachment.d.ts';
+export type * from './rx-collection.d.ts';
+export type * from './rx-database.d.ts';
+export type * from './rx-database-internal-store.d.ts';
+export type * from './rx-document.d.ts';
+export type * from './rx-error.d.ts';
+export type * from './rx-plugin.d.ts';
+export type * from './rx-query.d.ts';
+export type * from './rx-schema.d.ts';
+export type * from './rx-storage.d.ts';
+export type * from './rx-storage.interface.d.ts';
+export type * from './replication-protocol.d.ts';
+export type * from './conflict-handling.d.ts';
+export type * from './rx-change-event.d.ts';
+export type * from './query-planner.d.ts';
+export type * from './util.d.ts';
+
+// plugins
+export type * from './plugins/replication.d.ts';
+export type * from './plugins/replication-graphql.d.ts';
+export type * from './plugins/replication.d.ts';
+export type * from './plugins/local-documents.d.ts';
+export type * from './plugins/migration.d.ts';
+export type * from './plugins/backup.d.ts';
+export type * from './plugins/cleanup.d.ts';
+export type * from './plugins/dexie.d.ts';
+export type * from './plugins/reactivity.d.ts';
+export type * from './plugins/update.d.ts';
+export type * from './plugins/crdt.d.ts';
+export type * from './plugins/state.d.ts';
+export type * from './plugins/webmcp.d.ts';

package/dist/types/types/modules/mocha.parallel.d.ts

@@ -0,0 +1 @@
+declare module 'mocha.parallel';

package/dist/types/types/plugins/backup.d.ts

@@ -0,0 +1,35 @@
+export type BackupOptions = {
+    live: boolean;
+    directory: string;
+    /**
+     * If true,
+     * attachments will also be saved
+     */
+    attachments?: boolean;
+    /**
+     * How many documents can be processed in one batch
+     * [default=10]
+     */
+    batchSize?: number;
+    /**
+     * If not set, all collections will be backed up.
+     */
+    collections?: string[];
+};
+
+export type BackupMetaFileContent = {
+    createdAt: number;
+    updatedAt: number;
+    collectionStates: {
+        [collectionName: string]: {
+            checkpoint?: any;
+        };
+    };
+};
+
+export type RxBackupWriteEvent = {
+    collectionName: string;
+    documentId: string;
+    files: string[];
+    deleted: boolean;
+};

package/dist/types/types/plugins/cleanup.d.ts

@@ -0,0 +1,38 @@
+export type RxCleanupPolicy = {
+    /**
+     * The minimum time in milliseconds
+     * of how long a document must have been deleted
+     * until it is purged by the cleanup.
+     * This should be higher then the time you expect
+     * your user to be offline for.
+     * If this is too low, deleted documents might not
+     * replicate their deletion state.
+     */
+    minimumDeletedTime: number;
+    /**
+     * The minimum amount of time that the RxCollection must have existed.
+     * This ensures that at the initial page load, more important
+     * tasks are not slowed down because a cleanup process is running.
+     */
+    minimumCollectionAge: number;
+    /**
+     * After the initial cleanup is done,
+     * a new cleanup is started after [runEach] milliseconds
+     */
+    runEach: number;
+    /**
+     * If set to true,
+     * RxDB will await all running replications
+     * to not have a replication cycle running.
+     * This ensures we do not remove deleted documents
+     * when they might not have already been replicated.
+     */
+    awaitReplicationsInSync: boolean;
+    /**
+     * If true, it will only start the cleanup
+     * when the current instance is also the leader.
+     * This ensures that when RxDB is used in multiInstance mode,
+     * only one instance will start the cleanup.
+     */
+    waitForLeadership: boolean;
+};

package/dist/types/types/plugins/crdt.d.ts

@@ -0,0 +1,76 @@
+import type { MangoQuerySelector } from '../rx-query.d.ts';
+import type { StringKeys } from '../util.d.ts';
+import type { UpdateQuery } from './update.d.ts';
+
+
+export type CRDTEntry<RxDocType> = {
+    selector?: MangoQuerySelector<RxDocType>;
+    ifMatch?: UpdateQuery<RxDocType>;
+    ifNotMatch?: UpdateQuery<RxDocType>;
+};
+
+/**
+ * Options for the crdt plugin.
+ * We set these in the schema because changing them
+ * is not possible on the fly because it would
+ * close the document state in an unpredictable way.
+ */
+export type CRDTSchemaOptions<RxDocType> = {
+    /**
+     * Determines which field of the document must be used
+     * to store the crdt operations.
+     * The given field must exist with the content of "CRDT_FIELD_SCHEMA" in the
+     * properties part of your schema.
+     */
+    field: StringKeys<RxDocType> | string;
+
+    /**
+     * After BOTH of the limits
+     * maxOperations/maxTTL is reached,
+     * the document will clean up the stored operations
+     * and merged them together to ensure
+     * that not too many operations are stored which could slow down the
+     * database operations.
+     */
+    // TODO not implemented yet, make a pull request if you need that.
+    // maxOperations: number;
+    // maxTTL: number;
+};
+
+
+export type CRDTOperation<RxDocType> = {
+    body: CRDTEntry<RxDocType>[];
+    /**
+     * A string to uniquely represent the creator
+     * of this operation.
+     * Mostly you would use the RxDatabase().storageToken().
+     */
+    creator: string;
+
+    /**
+     * Unix time in milliseconds
+     * that determines when the operation was created.
+     * Used to properly clean up old operations.
+     */
+    time: number;
+};
+
+
+export type CRDTDocumentField<RxDocType> = {
+    /**
+     * An array with arrays of CRDT operations.
+     * The index of the top level array is equal
+     * to the revision height where the operations
+     * belong to.
+     * Sorted by revision height ascending.
+     * If we have a conflict and we need a rebuild,
+     * the operations will be run in the revision height
+     * sort order to make everything deterministic.
+     */
+    operations: CRDTOperation<RxDocType>[][];
+
+    /**
+     * A hash to uniquely define the whole operations state.
+     */
+    hash: string;
+};