@connecttomahdi/rxdb 17.0.0-beta.17

package/dist/types/plugins/test-utils/replication-base-test-suite.d.ts

@@ -0,0 +1,66 @@
+import type { RxCollection } from '../../types/index.d.ts';
+import type { RxReplicationState } from '../replication/index.ts';
+export type ReplicationBaseTestSuiteConfig = {
+    /**
+     * Start a live replication for a collection.
+     * Must target a shared server endpoint so that multiple
+     * collections can replicate to the same backend.
+     */
+    startReplication(collection: RxCollection<any>): RxReplicationState<any, any>;
+    /**
+     * Run a one-shot (non-live) sync and wait for completion.
+     * Must target the same server endpoint as startReplication.
+     */
+    syncOnce(collection: RxCollection<any>): Promise<void>;
+    /**
+     * Get all documents from the server,
+     * including soft-deleted ones when the backend uses soft deletes.
+     */
+    getAllServerDocs(): Promise<any[]>;
+    /**
+     * Remove all documents from the server.
+     */
+    cleanUpServer(): Promise<void>;
+    /**
+     * Whether the server uses soft deletes
+     * (marks docs as deleted instead of removing them).
+     */
+    softDeletes: boolean;
+    /**
+     * Check if a server document is marked as deleted.
+     * Required when softDeletes is true.
+     */
+    isDeleted?(serverDoc: any): boolean;
+    /**
+     * Get the client primary key (passportId) from a server document.
+     * Different backends store the primary key in different fields.
+     */
+    getPrimaryOfServerDoc(serverDoc: any): string;
+    /**
+     * Additional wait time for eventually consistent backends (ms).
+     */
+    waitTime?: number;
+};
+/**
+ * Runs the base test suite for a replication plugin.
+ * Call this inside a describe() block in your replication test file.
+ *
+ * The config callbacks should target a shared server endpoint.
+ * Each test calls cleanUpServer() at the start to ensure a clean state.
+ *
+ * @example
+ * ```ts
+ * describe('replication-nats.test.ts', () => {
+ *     runReplicationBaseTestSuite({
+ *         startReplication: (collection) => syncNats(collection, natsName),
+ *         syncOnce: (collection) => syncOnceNats(collection, natsName),
+ *         getAllServerDocs: () => getAllDocsOfServer(natsName),
+ *         cleanUpServer: async () => { ... },
+ *         softDeletes: true,
+ *         isDeleted: (doc) => doc._deleted,
+ *         getPrimaryOfServerDoc: (doc) => doc.passportId,
+ *     });
+ * });
+ * ```
+ */
+export declare function runReplicationBaseTestSuite(config: ReplicationBaseTestSuiteConfig): void;

package/dist/types/plugins/test-utils/replication.d.ts

@@ -0,0 +1,10 @@
+import { Observable } from 'rxjs';
+import type { ReplicationPullHandler, ReplicationPushHandler, RxCollection, RxReplicationPullStreamItem } from '../../types';
+/**
+ * Creates a pull handler that always returns
+ * all documents.
+*/
+export declare function getPullHandler<RxDocType, CheckpointType>(remoteCollection: RxCollection<RxDocType, {}, {}, {}>): ReplicationPullHandler<RxDocType, CheckpointType>;
+export declare function getPullStream<RxDocType>(remoteCollection: RxCollection<RxDocType, {}, {}, {}>): Observable<RxReplicationPullStreamItem<RxDocType, any>>;
+export declare function getPushHandler<RxDocType>(remoteCollection: RxCollection<RxDocType, {}, {}, {}>): ReplicationPushHandler<RxDocType>;
+export declare function ensureEqualState<RxDocType>(collectionA: RxCollection<RxDocType>, collectionB: RxCollection<RxDocType>, context?: string): Promise<void>;

package/dist/types/plugins/test-utils/revisions.d.ts

@@ -0,0 +1,4 @@
+export declare const EXAMPLE_REVISION_1 = "1-12080c42d471e3d2625e49dcca3b8e1a";
+export declare const EXAMPLE_REVISION_2 = "2-22080c42d471e3d2625e49dcca3b8e2b";
+export declare const EXAMPLE_REVISION_3 = "3-32080c42d471e3d2625e49dcca3b8e3c";
+export declare const EXAMPLE_REVISION_4 = "4-42080c42d471e3d2625e49dcca3b8e3c";

package/dist/types/plugins/test-utils/schema-objects.d.ts

@@ -0,0 +1,219 @@
+/**
+ * this file contains objects which match the schemas in schemas.js
+ */
+import { HumanDocumentType } from './schemas.ts';
+/**
+ * Some storages had problems with umlauts and other special chars.
+ * So we add these to all test strings.
+ */
+export declare const TEST_DATA_CHARSET = "0987654321ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\u00E4\u00F6\u00FC\u00D6\u00C4\u00DF\u00DC[]{}'";
+export declare const TEST_DATA_CHARSET_LAST_SORTED: string;
+export declare function randomStringWithSpecialChars(minLength: number, 
+/**
+ * It has shown that alternating string lengths
+ * can reproduce various problems. So by having variable
+ * lengths we ensure that this fully works.
+ */
+maxLength: number): string;
+export interface SimpleHumanDocumentType {
+    passportId: string;
+    firstName: string;
+    lastName: string;
+}
+export declare function humanData(passportId?: string, age?: number, firstName?: string): HumanDocumentType;
+export declare function simpleHumanData(): SimpleHumanDocumentType;
+export interface SimpleHumanV3DocumentType {
+    passportId: string;
+    age: number;
+    oneOptional?: string;
+}
+export declare function simpleHumanV3Data(partial?: Partial<SimpleHumanV3DocumentType>): SimpleHumanV3DocumentType;
+export interface SimpleHumanAgeDocumentType {
+    passportId: string;
+    age: string;
+}
+export declare function simpleHumanAge(partial?: Partial<SimpleHumanAgeDocumentType>): SimpleHumanAgeDocumentType;
+export interface HumanWithSubOtherDocumentType {
+    passportId: string;
+    other: {
+        age: number;
+    };
+}
+export declare function humanWithSubOther(): HumanWithSubOtherDocumentType;
+export interface NoIndexHumanDocumentType {
+    firstName: string;
+    lastName: string;
+}
+export declare function NoIndexHuman(): NoIndexHumanDocumentType;
+export interface NestedHumanDocumentType {
+    passportId: string;
+    firstName: string;
+    mainSkill: {
+        name: string;
+        level: number;
+    };
+}
+export declare function nestedHumanData(partial?: Partial<NestedHumanDocumentType>): NestedHumanDocumentType;
+export interface DeepNestedHumanDocumentType {
+    passportId: string;
+    mainSkill: {
+        name: string;
+        attack: {
+            good: boolean;
+            count: number;
+        };
+    };
+}
+export declare function deepNestedHumanData(): DeepNestedHumanDocumentType;
+export interface BigHumanDocumentType {
+    passportId: string;
+    dnaHash: string;
+    firstName: string;
+    lastName: string;
+    age: number;
+}
+export declare function bigHumanDocumentType(): BigHumanDocumentType;
+export interface HeroArrayDocumentType {
+    name: string;
+    skills: {
+        name: string;
+        damage: number;
+    }[];
+}
+export declare function heroArrayData(): HeroArrayDocumentType;
+export interface SimpleHeroArrayDocumentType {
+    name: string;
+    skills: string[];
+}
+export declare function simpleHeroArray(partial?: Partial<SimpleHeroArrayDocumentType>): SimpleHeroArrayDocumentType;
+export interface EncryptedHumanDocumentType {
+    passportId: string;
+    firstName: string;
+    secret: string;
+}
+export declare function encryptedHumanData(secret?: string): EncryptedHumanDocumentType;
+export interface EncryptedObjectHumanDocumentType {
+    passportId: string;
+    firstName: string;
+    secret: {
+        name: string;
+        subname: string;
+    };
+}
+export declare function encryptedObjectHumanData(): EncryptedObjectHumanDocumentType;
+export interface EncryptedDeepHumanDocumentType {
+    passportId: string;
+    firstName: string;
+    firstLevelPassword: string;
+    secretData: {
+        pw: string;
+    };
+    deepSecret: {
+        darkhole: {
+            pw: string;
+        };
+    };
+    nestedSecret: {
+        darkhole: {
+            pw: string;
+        };
+    };
+}
+export declare function encryptedDeepHumanDocumentType(): EncryptedDeepHumanDocumentType;
+export interface CompoundIndexDocumentType {
+    passportId: string;
+    passportCountry: string;
+    age: number;
+}
+export declare function compoundIndexData(): CompoundIndexDocumentType;
+export interface CompoundIndexNoStringDocumentType {
+    passportId: string;
+    passportCountry: {
+        [prop: string]: string;
+    };
+    age: number;
+}
+export declare function compoundIndexNoStringData(): CompoundIndexNoStringDocumentType;
+export interface NostringIndexDocumentType {
+    passportId: {};
+    firstName: string;
+}
+export declare function nostringIndex(): NostringIndexDocumentType;
+export interface RefHumanDocumentType {
+    name: string;
+    bestFriend: string;
+}
+export declare function refHumanData(bestFriend?: string): RefHumanDocumentType;
+export interface RefHumanNestedDocumentType {
+    name: string;
+    foo: {
+        bestFriend: string;
+    };
+}
+export declare function refHumanNestedData(bestFriend?: string): RefHumanNestedDocumentType;
+export interface HumanWithTimestampNestedDocumentType extends HumanWithTimestampDocumentType {
+    address?: {
+        street: string;
+        suite: string;
+        city: string;
+        zipcode: string;
+        geo: {
+            lat: string;
+            lng: string;
+        };
+    };
+}
+export interface HumanWithTimestampDocumentType {
+    id: string;
+    name: string;
+    age: number;
+    updatedAt: number;
+    deletedAt?: number;
+}
+export declare function humanWithTimestampData(givenData?: Partial<HumanWithTimestampDocumentType>): HumanWithTimestampDocumentType;
+export interface AverageSchemaDocumentType {
+    id: string;
+    var1: string;
+    var2: number;
+    deep: {
+        deep1: string;
+        deep2: string;
+        deeper: {
+            deepNr: number;
+        };
+    };
+    list: {
+        deep1: string;
+        deep2: string;
+    }[];
+}
+export declare function averageSchemaData(partial?: Partial<AverageSchemaDocumentType>): AverageSchemaDocumentType;
+export interface PointDocumentType {
+    id: string;
+    x: number;
+    y: number;
+}
+export declare function pointData(): PointDocumentType;
+export interface HumanWithIdAndAgeIndexDocumentType {
+    id: string;
+    name: string;
+    age: number;
+}
+export declare function humanWithIdAndAgeIndexDocumentType(age?: number): HumanWithIdAndAgeIndexDocumentType;
+export type HumanWithCompositePrimary = {
+    id?: string;
+    firstName: string;
+    lastName: string;
+    info: {
+        age: number;
+    };
+};
+export declare function humanWithCompositePrimary(partial?: Partial<HumanWithCompositePrimary>): HumanWithCompositePrimary;
+export type HumanWithOwnershipDocumentType = {
+    passportId: string;
+    firstName: string;
+    lastName: string;
+    age: number;
+    owner?: string;
+};
+export declare function humanWithOwnershipData(partial: Partial<HumanWithOwnershipDocumentType> | undefined, owner: string): HumanWithOwnershipDocumentType;

package/dist/types/plugins/test-utils/schemas.d.ts

@@ -0,0 +1,356 @@
+import { SimpleHumanV3DocumentType, HumanWithSubOtherDocumentType, NestedHumanDocumentType, DeepNestedHumanDocumentType, EncryptedHumanDocumentType, EncryptedObjectHumanDocumentType, EncryptedDeepHumanDocumentType, CompoundIndexDocumentType, CompoundIndexNoStringDocumentType, HeroArrayDocumentType, SimpleHeroArrayDocumentType, RefHumanDocumentType, RefHumanNestedDocumentType, AverageSchemaDocumentType, PointDocumentType, HumanWithTimestampDocumentType, BigHumanDocumentType, NostringIndexDocumentType, NoIndexHumanDocumentType, HumanWithCompositePrimary, HumanWithTimestampNestedDocumentType } from './schema-objects.ts';
+import type { ExtractDocumentTypeFromTypedRxJsonSchema, RxJsonSchema } from '../../types/rx-schema';
+export declare const humanSchemaLiteral: import("../../index.ts").DeepReadonlyObject<{
+    readonly title: "human schema";
+    readonly description: "describes a human being";
+    readonly version: 0;
+    readonly keyCompression: false;
+    readonly primaryKey: "passportId";
+    readonly type: "object";
+    readonly properties: {
+        readonly passportId: {
+            readonly type: "string";
+            readonly maxLength: 100;
+        };
+        readonly firstName: {
+            readonly type: "string";
+            readonly maxLength: 100;
+        };
+        readonly lastName: {
+            readonly type: "string";
+            readonly maxLength: 100;
+        };
+        readonly age: {
+            readonly description: "age in years";
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly maximum: 150;
+            readonly multipleOf: 1;
+        };
+    };
+    readonly required: readonly ["firstName", "lastName", "passportId"];
+    readonly indexes: readonly ["firstName"];
+}>;
+declare const humanSchemaTyped: {
+    title: "human schema";
+    description: "describes a human being";
+    version: 0;
+    keyCompression: false;
+    primaryKey: "passportId";
+    type: "object";
+    properties: {
+        passportId: {
+            type: "string";
+            maxLength: 100;
+        };
+        firstName: {
+            type: "string";
+            maxLength: 100;
+        };
+        lastName: {
+            type: "string";
+            maxLength: 100;
+        };
+        age: {
+            description: "age in years";
+            type: "integer";
+            minimum: 0;
+            maximum: 150;
+            multipleOf: 1;
+        };
+    };
+    required: ["firstName", "lastName", "passportId"];
+    indexes: ["firstName"];
+};
+export type HumanDocumentType = ExtractDocumentTypeFromTypedRxJsonSchema<typeof humanSchemaTyped>;
+export declare const human: RxJsonSchema<HumanDocumentType>;
+export declare const humanDefault: RxJsonSchema<HumanDocumentType>;
+export declare const humanFinal: RxJsonSchema<HumanDocumentType>;
+export declare const simpleHuman: RxJsonSchema<SimpleHumanV3DocumentType>;
+export declare const simpleHumanV3: RxJsonSchema<SimpleHumanV3DocumentType>;
+export declare const humanAgeIndex: RxJsonSchema<HumanDocumentType>;
+export declare const humanSubIndex: RxJsonSchema<HumanWithSubOtherDocumentType>;
+/**
+ * each field is an index,
+ * use this to slow down inserts in tests
+ */
+export declare const humanWithAllIndex: RxJsonSchema<HumanDocumentType>;
+export declare const nestedHuman: RxJsonSchema<NestedHumanDocumentType>;
+export declare const deepNestedHuman: RxJsonSchema<DeepNestedHumanDocumentType>;
+export declare const noIndexHuman: RxJsonSchema<NoIndexHumanDocumentType>;
+export declare const noStringIndex: RxJsonSchema<NostringIndexDocumentType>;
+export declare const bigHuman: RxJsonSchema<BigHumanDocumentType>;
+export declare const encryptedHuman: RxJsonSchema<EncryptedHumanDocumentType>;
+export declare const encryptedObjectHuman: RxJsonSchema<EncryptedObjectHumanDocumentType>;
+export declare const encryptedDeepHuman: RxJsonSchema<EncryptedDeepHumanDocumentType>;
+export declare const notExistingIndex: RxJsonSchema<{
+    passportId: string;
+    address: {
+        street: string;
+    };
+}>;
+export declare const compoundIndex: RxJsonSchema<CompoundIndexDocumentType>;
+export declare const compoundIndexNoString: RxJsonSchema<CompoundIndexNoStringDocumentType>;
+export declare const empty: RxJsonSchema<any>;
+export declare const heroArray: RxJsonSchema<HeroArrayDocumentType>;
+export declare const simpleArrayHero: RxJsonSchema<SimpleHeroArrayDocumentType>;
+export declare const primaryHumanLiteral: import("../../index.ts").DeepReadonlyObject<{
+    readonly title: "human schema with primary";
+    readonly version: 0;
+    readonly description: "describes a human being with passportID as primary";
+    readonly keyCompression: false;
+    readonly primaryKey: "passportId";
+    readonly type: "object";
+    readonly properties: {
+        readonly passportId: {
+            readonly type: "string";
+            readonly minLength: 4;
+            readonly maxLength: 100;
+        };
+        readonly firstName: {
+            readonly type: "string";
+            readonly maxLength: 100;
+        };
+        readonly lastName: {
+            readonly type: "string";
+            readonly maxLength: 500;
+        };
+        readonly age: {
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly maximum: 150;
+            readonly multipleOf: 1;
+        };
+    };
+    readonly required: readonly ["passportId", "firstName", "lastName"];
+}>;
+declare const primaryHumanTypedSchema: {
+    title: "human schema with primary";
+    version: 0;
+    description: "describes a human being with passportID as primary";
+    keyCompression: false;
+    primaryKey: "passportId";
+    type: "object";
+    properties: {
+        passportId: {
+            type: "string";
+            minLength: 4;
+            maxLength: 100;
+        };
+        firstName: {
+            type: "string";
+            maxLength: 100;
+        };
+        lastName: {
+            type: "string";
+            maxLength: 500;
+        };
+        age: {
+            type: "integer";
+            minimum: 0;
+            maximum: 150;
+            multipleOf: 1;
+        };
+    };
+    required: ["passportId", "firstName", "lastName"];
+};
+export type PrimaryHumanDocType = ExtractDocumentTypeFromTypedRxJsonSchema<typeof primaryHumanTypedSchema>;
+export declare const primaryHuman: RxJsonSchema<PrimaryHumanDocType>;
+export declare const humanNormalizeSchema1Literal: import("../../index.ts").DeepReadonlyObject<{
+    readonly title: "human schema";
+    readonly version: 0;
+    readonly keyCompression: false;
+    readonly description: "describes a human being";
+    readonly primaryKey: "passportId";
+    readonly type: "object";
+    readonly properties: {
+        readonly passportId: {
+            readonly type: "string";
+            readonly minLength: 4;
+            readonly maxLength: 100;
+        };
+        readonly age: {
+            readonly description: "age in years";
+            readonly type: "integer";
+            readonly minimum: 0;
+            readonly maximum: 150;
+            readonly multipleOf: 1;
+        };
+    };
+    readonly required: readonly ["age", "passportId"];
+}>;
+declare const humanNormalizeSchema1Typed: {
+    title: "human schema";
+    version: 0;
+    keyCompression: false;
+    description: "describes a human being";
+    primaryKey: "passportId";
+    type: "object";
+    properties: {
+        passportId: {
+            type: "string";
+            minLength: 4;
+            maxLength: 100;
+        };
+        age: {
+            description: "age in years";
+            type: "integer";
+            minimum: 0;
+            maximum: 150;
+            multipleOf: 1;
+        };
+    };
+    required: ["age", "passportId"];
+};
+export type AgeHumanDocumentType = ExtractDocumentTypeFromTypedRxJsonSchema<typeof humanNormalizeSchema1Typed>;
+export declare const humanNormalizeSchema1: RxJsonSchema<AgeHumanDocumentType>;
+export declare const humanNormalizeSchema2: RxJsonSchema<AgeHumanDocumentType>;
+export declare const refHuman: RxJsonSchema<RefHumanDocumentType>;
+export declare const humanCompositePrimary: RxJsonSchema<HumanWithCompositePrimary>;
+export declare const humanCompositePrimarySchemaLiteral: import("../../index.ts").DeepReadonlyObject<{
+    readonly title: "human schema";
+    readonly description: "describes a human being";
+    readonly version: 0;
+    readonly keyCompression: false;
+    readonly primaryKey: {
+        readonly key: "id";
+        readonly fields: readonly ["firstName", "info.age"];
+        readonly separator: "|";
+    };
+    readonly encrypted: readonly [];
+    readonly type: "object";
+    readonly properties: {
+        readonly id: {
+            readonly type: "string";
+            readonly maxLength: 100;
+        };
+        readonly firstName: {
+            readonly type: "string";
+            readonly maxLength: 100;
+        };
+        readonly lastName: {
+            readonly type: "string";
+        };
+        readonly info: {
+            readonly type: "object";
+            readonly properties: {
+                readonly age: {
+                    readonly description: "age in years";
+                    readonly type: "integer";
+                    readonly minimum: 0;
+                    readonly maximum: 150;
+                };
+            };
+            readonly required: readonly ["age"];
+        };
+        readonly readonlyProps: {
+            readonly allOf: readonly [];
+            readonly anyOf: readonly [];
+            readonly oneOf: readonly [];
+            readonly type: readonly [];
+            readonly dependencies: {
+                readonly someDep: readonly ["asd"];
+            };
+            readonly items: readonly [];
+            readonly required: readonly [];
+            readonly enum: readonly [];
+        };
+    };
+    readonly required: readonly ["id", "firstName", "lastName", "info"];
+    readonly indexes: readonly ["firstName"];
+}>;
+declare const humanCompositePrimarySchemaTyped: {
+    title: "human schema";
+    description: "describes a human being";
+    version: 0;
+    keyCompression: false;
+    primaryKey: {
+        key: "id";
+        fields: ["firstName", "info.age"];
+        separator: "|";
+    };
+    encrypted: [];
+    type: "object";
+    properties: {
+        id: {
+            type: "string";
+            maxLength: 100;
+        };
+        firstName: {
+            type: "string";
+            maxLength: 100;
+        };
+        lastName: {
+            type: "string";
+        };
+        info: {
+            type: "object";
+            properties: {
+                age: {
+                    description: "age in years";
+                    type: "integer";
+                    minimum: 0;
+                    maximum: 150;
+                };
+            };
+            required: ["age"];
+        };
+        readonlyProps: {
+            allOf: [];
+            anyOf: [];
+            oneOf: [];
+            type: [];
+            dependencies: {
+                someDep: ["asd"];
+            };
+            items: [];
+            required: [];
+            enum: [];
+        };
+    };
+    required: ["id", "firstName", "lastName", "info"];
+    indexes: ["firstName"];
+};
+export type HumanCompositePrimaryDocType = ExtractDocumentTypeFromTypedRxJsonSchema<typeof humanCompositePrimarySchemaTyped>;
+export declare const refHumanNested: RxJsonSchema<RefHumanNestedDocumentType>;
+/**
+ * an average schema used in performance-tests
+ */
+export declare function averageSchema(): RxJsonSchema<AverageSchemaDocumentType>;
+export declare const point: RxJsonSchema<PointDocumentType>;
+export declare const humanMinimal: RxJsonSchema<SimpleHumanV3DocumentType>;
+export declare const humanMinimalBroken: RxJsonSchema<{
+    passportId: string;
+    broken: number;
+}>;
+/**
+ * used in the graphql-test
+ * contains timestamp
+ */
+export declare const humanWithTimestamp: RxJsonSchema<HumanWithTimestampDocumentType>;
+export declare const humanWithTimestampNested: RxJsonSchema<HumanWithTimestampNestedDocumentType>;
+/**
+ * each field is an index,
+ * use this to slow down inserts in tests
+ */
+export declare const humanWithTimestampAllIndex: RxJsonSchema<HumanWithTimestampDocumentType>;
+export declare const humanWithSimpleAndCompoundIndexes: RxJsonSchema<{
+    id: string;
+    name: string;
+    age: number;
+    createdAt: number;
+    updatedAt: number;
+}>;
+export declare const humanWithDeepNestedIndexes: RxJsonSchema<{
+    id: string;
+    name: string;
+    job: any;
+}>;
+export declare const humanIdAndAgeIndex: RxJsonSchema<{
+    id: string;
+    name: string;
+    age: number;
+}>;
+export declare const humanWithOwnership: RxJsonSchema<HumanDocumentType>;
+export declare function enableKeyCompression<RxDocType>(schema: RxJsonSchema<RxDocType>): RxJsonSchema<RxDocType>;
+export {};

package/dist/types/plugins/test-utils/test-util.d.ts

@@ -0,0 +1,10 @@
+import type { Func } from 'mocha';
+import type { RxCollection } from '../../types';
+import type { RxReplicationState } from '../replication/index.ts';
+export declare function testMultipleTimes(times: number, title: string, test: Func): void;
+export declare function ensureCollectionsHaveEqualState<RxDocType>(c1: RxCollection<RxDocType>, c2: RxCollection<RxDocType>, logContext?: string): Promise<void>;
+/**
+ * Waits until the collections have the equal state.
+ */
+export declare function awaitCollectionsHaveEqualState<RxDocType>(c1: RxCollection<RxDocType>, c2: RxCollection<RxDocType>, logContext?: string, timeout?: number): Promise<void>;
+export declare function ensureReplicationHasNoErrors(replicationState: RxReplicationState<any, any>): void;

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

@@ -0,0 +1,5 @@
+import type { RxDocument, RxQuery, RxPlugin, UpdateQuery } from '../../types/index.d.ts';
+export declare function incrementalUpdate<RxDocType>(this: RxDocument<RxDocType>, updateObj: UpdateQuery<RxDocType>): Promise<RxDocument<RxDocType>>;
+export declare function update<RxDocType>(this: RxDocument<RxDocType>, updateObj: UpdateQuery<RxDocType>): Promise<RxDocument<RxDocType>>;
+export declare function RxQueryUpdate(this: RxQuery, updateObj: UpdateQuery<any>): Promise<any>;
+export declare const RxDBUpdatePlugin: RxPlugin;

package/dist/types/plugins/update/mingo-updater.d.ts

@@ -0,0 +1,2 @@
+import type { UpdateQuery } from '../../types/index';
+export declare function mingoUpdater<T>(d: T, op: UpdateQuery<T>): T;