dexie-cloud-addon 4.2.5 → 4.3.0

package/dist/umd/sync/DEXIE_CLOUD_SYNCER_ID.d.ts

@@ -0,0 +1 @@
+export declare const DEXIE_CLOUD_SYNCER_ID = "dexie-cloud-syncer";

package/dist/umd/sync/LocalSyncWorker.d.ts

@@ -0,0 +1,7 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { DexieCloudOptions } from '../DexieCloudOptions';
+import { DexieCloudSchema } from 'dexie-cloud-common';
+export declare function LocalSyncWorker(db: DexieCloudDB, cloudOptions: DexieCloudOptions, cloudSchema: DexieCloudSchema): {
+    start: () => void;
+    stop: () => void;
+};

package/dist/umd/sync/SyncRequiredError.d.ts

@@ -0,0 +1,3 @@
+export declare class SyncRequiredError extends Error {
+    name: string;
+}

package/dist/umd/sync/applyServerChanges.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { DBOperationsSet } from 'dexie-cloud-common';
+export declare function applyServerChanges(changes: DBOperationsSet<string>, db: DexieCloudDB): Promise<void>;

package/dist/umd/sync/connectWebSocket.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function connectWebSocket(db: DexieCloudDB): import("rxjs").Subscription;

package/dist/umd/sync/encodeIdsForServer.d.ts

@@ -0,0 +1,4 @@
+import { DBCoreSchema } from 'dexie';
+import { DBOperationsSet } from 'dexie-cloud-common';
+import { UserLogin } from '../db/entities/UserLogin';
+export declare function encodeIdsForServer(schema: DBCoreSchema, currentUser: UserLogin, changes: DBOperationsSet): DBOperationsSet;

package/dist/umd/sync/extractRealm.d.ts

@@ -0,0 +1,2 @@
+import { EntityCommon } from "../db/entities/EntityCommon";
+export declare function extractRealm(obj: EntityCommon): string | undefined;

package/dist/umd/sync/getLatestRevisionsPerTable.d.ts

@@ -0,0 +1,6 @@
+import { DBOperationsSet } from 'dexie-cloud-common';
+export declare function getLatestRevisionsPerTable(clientChangeSet: DBOperationsSet, lastRevisions?: {
+    [table: string]: number;
+}): {
+    [table: string]: number;
+};

package/dist/umd/sync/getTablesToSyncify.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudDB } from "../db/DexieCloudDB";
+import { PersistedSyncState } from "../db/entities/PersistedSyncState";
+export declare function getTablesToSyncify(db: DexieCloudDB, syncState: PersistedSyncState | undefined): import("dexie").Table<import("../db/entities/EntityCommon").EntityCommon, any, import("../db/entities/EntityCommon").EntityCommon>[];

package/dist/umd/sync/isOnline.d.ts

@@ -0,0 +1 @@
+export declare let isOnline: boolean;

package/dist/umd/sync/isSyncNeeded.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from "../db/DexieCloudDB";
+export declare function isSyncNeeded(db: DexieCloudDB): Promise<boolean>;

package/dist/umd/sync/listClientChanges.d.ts

@@ -0,0 +1,9 @@
+import { Table } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { DBOperationsSet } from 'dexie-cloud-common';
+export declare function listClientChanges(mutationTables: Table[], db: DexieCloudDB, { since, limit }?: {
+    since?: {
+        [table: string]: number;
+    } | undefined;
+    limit?: number | undefined;
+}): Promise<DBOperationsSet>;

package/dist/umd/sync/listSyncifiedChanges.d.ts

@@ -0,0 +1,5 @@
+import { UserLogin } from '../db/entities/UserLogin';
+import { EntityCommon } from '../db/entities/EntityCommon';
+import { Table } from 'dexie';
+import { DBOperationsSet, DexieCloudSchema } from 'dexie-cloud-common';
+export declare function listSyncifiedChanges(tablesToSyncify: Table<EntityCommon>[], currentUser: UserLogin, schema: DexieCloudSchema, alreadySyncedRealms?: string[]): Promise<DBOperationsSet>;

package/dist/umd/sync/messageConsumerIsReady.d.ts

@@ -0,0 +1,2 @@
+import { BehaviorSubject } from "rxjs";
+export declare const messageConsumerIsReady: BehaviorSubject<boolean>;

package/dist/umd/sync/messagesFromServerQueue.d.ts

@@ -0,0 +1,8 @@
+import { BehaviorSubject } from 'rxjs';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { WSConnectionMsg } from '../WSObservable';
+export type MessagesFromServerConsumer = ReturnType<typeof MessagesFromServerConsumer>;
+export declare function MessagesFromServerConsumer(db: DexieCloudDB): {
+    enqueue: (msg: WSConnectionMsg) => void;
+    readyToServe: BehaviorSubject<boolean>;
+};

package/dist/umd/sync/modifyLocalObjectsWithNewUserId.d.ts

@@ -0,0 +1,4 @@
+import { Table } from "dexie";
+import { EntityCommon } from "../db/entities/EntityCommon";
+import { UserLogin } from "../db/entities/UserLogin";
+export declare function modifyLocalObjectsWithNewUserId(syncifiedTables: Table<EntityCommon>[], currentUser: UserLogin, alreadySyncedRealms?: string[]): Promise<void>;

package/dist/umd/sync/myId.d.ts

@@ -0,0 +1 @@
+export declare const myId: string;

package/dist/umd/sync/numUnsyncedMutations.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from "../db/DexieCloudDB";
+export declare function getNumUnsyncedMutationsObservable(db: DexieCloudDB): import("rxjs").Observable<number>;

package/dist/umd/sync/old_startSyncingClientChanges.d.ts

@@ -0,0 +1,39 @@
+/** TODO:
+ * 1. Convert these unsynced changes into sync mutations by resolving values from ordinaryTables.
+ * 2. Append a convertion of mutReqs[table].muts into sync mutations.
+ * 3. Send all this using fetch
+ * 4. if successful response, delete muts from mutTables by
+ *    1. a new rw-transaction where we start by finding revs above those we generated.
+ *    2. for tables where none such found, clear the table. if some of those found, deleteRange on the table.
+ *
+ * Tankar att följa upp:
+ *  * Varje DOM environmnet får en MutationSyncer
+ *  * Håller koll på huruvida den tror att en sync redan pågår eller inte.
+ *  * Bro
+ *
+ * Leader election
+ *  * IDB persisted value: leaderId
+ *  * Varje browsing-env får en nodeId (random string).
+ *  * db.open: Kolla om det finns en leader. Om inte, sätt dig själv som leader.
+ *  * Leaders: Ha sync consumer uppe.
+ *  * Service worker: Ta ledarskap. Spara även en prop som säger att detta är service worker (för att workaround BroadCastChannel props)
+ *  * Om det finns en non-service worker ledare, försök kontakta den (via BroadCastChannel)
+ *  * Om ledaren inte svarar inom 1 sekund, ta ledarskap.
+ *  * Ledare: Lyssna på ändring av ledarskap och sluta vara ledare i så fall.
+ *  * Följare: Lyssna på ändring av ledarskap så att du alltid kontaktar rätt ledare.
+ *  * När man postar något till non-SW ledaren så ska den ACKa inom 1 sek. Annars, ta ledarskapet.
+ *
+ *
+ * Enklare:
+ *  * Vi har en som leker service worker per window. Två aktiva flikar:
+ *     * Båda vaknar upp och låser tabellen X för skrivning, om ingen annan tagit jobbet, skriver timestamp till X och
+ *       börjar sedan synka. Under tiden för sync, uppdaterar den timestamp kontinuerligt för att signallera att den
+ *       jobbar. När klar, clearar ut timestampen och avslutar jobbet.
+ *       - Om det inte fanns nåt att göra så clearas timestamp ut och man schedulerar inget mer uppvaknande.
+ *     * Den som kom sist ser att annan tagit jobbet inom rimlig timestamp och väljer då att polla igen ifall timestampet
+ *       skulle timat ut.
+ *     * Om jobbaren verkar tajma ut: gör nytt försök från början. Kan leda till att du blir ledare denna gång.
+ *     * Om jobbaren clearar ut timestampen pga avslutat jobb så kan väntaren ädnå för säkerhets-skull göra om'et från början.
+ *
+ *
+ */

package/dist/umd/sync/performGuardedJob.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from "../db/DexieCloudDB";
+export declare function performGuardedJob<T>(db: DexieCloudDB, jobName: string, job: () => Promise<T>): Promise<T>;

package/dist/umd/sync/ratelimit.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function checkSyncRateLimitDelay(db: DexieCloudDB): Promise<void>;
+export declare function updateSyncRateLimitDelays(db: DexieCloudDB, res: Response): void;

package/dist/umd/sync/registerSyncEvent.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function registerSyncEvent(db: DexieCloudDB, purpose: "push" | "pull"): Promise<void>;
+export declare function registerPeriodicSyncEvent(db: DexieCloudDB): Promise<void>;

package/dist/umd/sync/sync.d.ts

@@ -0,0 +1,15 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { DexieCloudOptions } from '../DexieCloudOptions';
+import { DBOperationsSet, DexieCloudSchema } from 'dexie-cloud-common';
+export declare const CURRENT_SYNC_WORKER = "currentSyncWorker";
+export interface SyncOptions {
+    isInitialSync?: boolean;
+    cancelToken?: {
+        cancelled: boolean;
+    };
+    justCheckIfNeeded?: boolean;
+    retryImmediatelyOnFetchError?: boolean;
+    purpose?: 'pull' | 'push';
+}
+export declare function sync(db: DexieCloudDB, options: DexieCloudOptions, schema: DexieCloudSchema, syncOptions?: SyncOptions): Promise<boolean>;
+export declare function filterServerChangesThroughAddedClientChanges(serverChanges: DBOperationsSet<string>, addedClientChanges: DBOperationsSet): DBOperationsSet<string>;

package/dist/umd/sync/syncIfPossible.d.ts

@@ -0,0 +1,5 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { SyncOptions } from './sync';
+import { DexieCloudOptions } from '../DexieCloudOptions';
+import { DexieCloudSchema } from 'dexie-cloud-common';
+export declare function syncIfPossible(db: DexieCloudDB, cloudOptions: DexieCloudOptions, cloudSchema: DexieCloudSchema, options?: SyncOptions): any;

package/dist/umd/sync/syncWithServer.d.ts

@@ -0,0 +1,6 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { PersistedSyncState } from '../db/entities/PersistedSyncState';
+import { BaseRevisionMapEntry } from '../db/entities/BaseRevisionMapEntry';
+import { DBOperationsSet, DexieCloudSchema, SyncResponse, YClientMessage } from 'dexie-cloud-common';
+import { UserLogin } from '../db/entities/UserLogin';
+export declare function syncWithServer(changes: DBOperationsSet, y: YClientMessage[], syncState: PersistedSyncState | undefined, baseRevs: BaseRevisionMapEntry[], db: DexieCloudDB, databaseUrl: string, schema: DexieCloudSchema | null, clientIdentity: string, currentUser: UserLogin): Promise<SyncResponse>;

package/dist/umd/sync/triggerSync.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from "../db/DexieCloudDB";
+export declare function triggerSync(db: DexieCloudDB, purpose: "push" | "pull"): void;

package/dist/umd/sync/updateBaseRevs.d.ts

@@ -0,0 +1,5 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { DexieCloudSchema } from 'dexie-cloud-common';
+export declare function updateBaseRevs(db: DexieCloudDB, schema: DexieCloudSchema, latestRevisions: {
+    [table: string]: number;
+}, serverRev: any): Promise<void>;

package/dist/umd/types/DXCAlert.d.ts

@@ -0,0 +1,25 @@
+export type DXCAlert = DXCErrorAlert | DXCWarningAlert | DXCInfoAlert;
+export interface DXCErrorAlert {
+    type: 'error';
+    messageCode: 'INVALID_OTP' | 'INVALID_EMAIL' | 'LICENSE_LIMIT_REACHED' | 'GENERIC_ERROR';
+    message: string;
+    messageParams: {
+        [paramName: string]: string;
+    };
+}
+export interface DXCWarningAlert {
+    type: 'warning';
+    messageCode: 'GENERIC_WARNING' | 'LOGOUT_CONFIRMATION';
+    message: string;
+    messageParams: {
+        [paramName: string]: string;
+    };
+}
+export interface DXCInfoAlert {
+    type: 'info';
+    messageCode: 'GENERIC_INFO' | 'OTP_SENT';
+    message: string;
+    messageParams: {
+        [paramName: string]: string;
+    };
+}

package/dist/umd/types/DXCInputField.d.ts

@@ -0,0 +1,11 @@
+export type DXCInputField = DXCTextField | DXCPasswordField;
+export interface DXCTextField {
+    type: 'text' | 'email' | 'otp';
+    label?: string;
+    placeholder?: string;
+}
+export interface DXCPasswordField {
+    type: 'password';
+    label?: string;
+    placeholder?: string;
+}

package/dist/umd/types/DXCUserInteraction.d.ts

@@ -0,0 +1,93 @@
+import { DXCAlert } from './DXCAlert';
+import { DXCInputField } from './DXCInputField';
+export type DXCUserInteraction = DXCGenericUserInteraction | DXCEmailPrompt | DXCOTPPrompt | DXCMessageAlert | DXCLogoutConfirmation;
+export interface DXCGenericUserInteraction<Type extends string = "generic", TFields extends {
+    [name: string]: DXCInputField;
+} = any> {
+    type: Type;
+    title: string;
+    alerts: DXCAlert[];
+    fields: TFields;
+    submitLabel: string;
+    cancelLabel: string | null;
+    onSubmit: (params: {
+        [P in keyof TFields]: string;
+    }) => void;
+    onCancel: () => void;
+}
+/** When the system needs to prompt for an email address for login.
+ *
+*/
+export interface DXCEmailPrompt {
+    type: 'email';
+    title: string;
+    alerts: DXCAlert[];
+    fields: {
+        email: {
+            type: 'text';
+            placeholder: string;
+        };
+    };
+    submitLabel: string;
+    cancelLabel: string;
+    onSubmit: (params: {
+        email: string;
+    } | {
+        [paramName: string]: string;
+    }) => void;
+    onCancel: () => void;
+}
+/** When the system needs to prompt for an OTP code.
+ *
+*/
+export interface DXCOTPPrompt {
+    type: 'otp';
+    title: string;
+    alerts: DXCAlert[];
+    fields: {
+        otp: {
+            type: 'text';
+            label: string;
+        };
+    };
+    submitLabel: string;
+    cancelLabel: string;
+    onSubmit: (params: {
+        otp: string;
+    } | {
+        [paramName: string]: string;
+    }) => void;
+    onCancel: () => void;
+}
+/** When the system must inform about errors, warnings or information */
+export interface DXCMessageAlert {
+    type: 'message-alert';
+    title: string;
+    alerts: DXCAlert[];
+    fields: {
+        [name: string]: DXCInputField;
+    };
+    submitLabel: string;
+    cancelLabel?: null;
+    onSubmit: (params: {
+        [paramName: string]: string;
+    }) => void;
+    onCancel: () => void;
+}
+/** When the system needs confirmation to logout current user when
+ * there are unsynced changes that would be lost.
+ */
+export interface DXCLogoutConfirmation {
+    type: 'logout-confirmation';
+    title: string;
+    alerts: DXCAlert[];
+    fields: {
+        [name: string]: DXCInputField;
+    };
+    submitLabel: string;
+    cancelLabel: string;
+    onSubmit: (params: {
+        [paramName: string]: string;
+    }) => void;
+    onCancel: () => void;
+}

package/dist/umd/types/NewIdOptions.d.ts

@@ -0,0 +1,3 @@
+export interface NewIdOptions {
+    colocateWith?: string;
+}

package/dist/umd/types/SWMessageEvent.d.ts

@@ -0,0 +1,3 @@
+export interface SWMessageEvent extends MessageEvent {
+    waitUntil(promise: Promise<any>): void;
+}

package/dist/umd/types/SWSyncEvent.d.ts

@@ -0,0 +1,4 @@
+export type SyncEvent = Event & {
+    tag: string;
+    waitUntil(promise: Promise<any>): void;
+};

package/dist/umd/types/SyncState.d.ts

@@ -0,0 +1,9 @@
+export type SyncStatePhase = "initial" | "not-in-sync" | "pushing" | "pulling" | "in-sync" | 'error' | 'offline';
+export type SyncStatus = "not-started" | "connecting" | "connected" | "disconnected" | "error" | "offline";
+export interface SyncState {
+    status: SyncStatus;
+    phase: SyncStatePhase;
+    progress?: number;
+    error?: Error;
+    license?: 'ok' | 'expired' | 'deactivated';
+}

package/dist/umd/types/TXExpandos.d.ts

@@ -0,0 +1,11 @@
+import { DexieCloudSchema } from "dexie-cloud-common";
+import { UserLogin } from '../db/entities/UserLogin';
+export interface TXExpandos {
+    txid: string;
+    currentUser: UserLogin;
+    schema: DexieCloudSchema;
+    disableChangeTracking?: boolean;
+    disableAccessControl?: boolean;
+    mutationsAdded?: boolean;
+    opCount: number;
+}

package/dist/umd/updateSchemaFromOptions.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudSchema } from "dexie-cloud-common";
+import { DexieCloudOptions } from "./DexieCloudOptions";
+export declare function updateSchemaFromOptions(schema?: DexieCloudSchema | null, options?: DexieCloudOptions | null): void;

package/dist/umd/userIsActive.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject } from 'rxjs';
+export declare const userIsActive: BehaviorSubject<boolean>;
+export declare const userIsReallyActive: BehaviorSubject<boolean>;
+export declare const visibilityStateIsChanged: import("rxjs").Observable<{}>;
+export declare const documentBecomesHidden: import("rxjs").Observable<{}>;
+export declare const documentBecomesVisible: import("rxjs").Observable<{}>;
+export declare const userDoesSomething: import("rxjs").Observable<Event | {}>;

package/dist/umd/verifyConfig.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudOptions } from "./DexieCloudOptions";
+export declare function verifyConfig({ databaseUrl }?: DexieCloudOptions): void;

package/dist/umd/verifySchema.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from "./db/DexieCloudDB";
+export declare function verifySchema(db: DexieCloudDB): void;

package/dist/umd/yjs/YDexieCloudSyncState.d.ts

@@ -0,0 +1,3 @@
+import type { YSyncState } from 'y-dexie';
+export interface YDexieCloudSyncState extends YSyncState {
+}

package/dist/umd/yjs/YTable.d.ts

@@ -0,0 +1,3 @@
+import { EntityTable } from "dexie";
+import type { YUpdateRow } from "y-dexie";
+export type YTable = EntityTable<YUpdateRow, "i">;

package/dist/umd/yjs/applyYMessages.d.ts

@@ -0,0 +1,9 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { YServerMessage } from 'dexie-cloud-common';
+export declare function applyYServerMessages(yMessages: YServerMessage[], db: DexieCloudDB): Promise<{
+    receivedUntils: {
+        [yTable: string]: number;
+    };
+    resyncNeeded: boolean;
+    yServerRevision?: string;
+}>;

package/dist/umd/yjs/awareness.d.ts

@@ -0,0 +1,3 @@
+import type { Awareness } from 'y-protocols/awareness';
+export declare const awarenessWeakMap: WeakMap<any, Awareness>;
+export declare const getDocAwareness: (doc: any) => Awareness | undefined;

package/dist/umd/yjs/createYClientUpdateObservable.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import { YClientMessage } from 'dexie-cloud-common';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createYClientUpdateObservable(db: DexieCloudDB): Observable<YClientMessage>;

package/dist/umd/yjs/createYHandler.d.ts

@@ -0,0 +1,2 @@
+import type { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createYHandler(db: DexieCloudDB): (provider: import("y-dexie").DexieYProvider) => void;

package/dist/umd/yjs/downloadYDocsFromServer.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { PersistedSyncState } from '../db/entities/PersistedSyncState';
+export declare function downloadYDocsFromServer(db: DexieCloudDB, databaseUrl: string, { yDownloadedRealms, realms }: PersistedSyncState): Promise<void>;

package/dist/umd/yjs/getUpdatesTable.d.ts

@@ -0,0 +1,3 @@
+import { DexieCloudDB } from "../db/DexieCloudDB";
+import { YTable } from "./YTable";
+export declare function getUpdatesTable(db: DexieCloudDB, table: string, ydocProp: string): YTable | undefined;

package/dist/umd/yjs/listUpdatesSince.d.ts

@@ -0,0 +1,3 @@
+import type { Table } from 'dexie';
+import type { YUpdateRow } from 'y-dexie';
+export declare function listUpdatesSince(yTable: Table, sinceIncluding: number): Promise<YUpdateRow[]>;

package/dist/umd/yjs/listYClientMessagesAndStateVector.d.ts

@@ -0,0 +1,26 @@
+import type { Table } from 'dexie';
+import type { YClientMessage } from 'dexie-cloud-common';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { EntityCommon } from '../db/entities/EntityCommon';
+/** Queries the local database for YMessages to send to server.
+ *
+ * There are 2 messages that this function can provide:
+ *   YUpdateFromClientRequest ( for local updates )
+ *   YStateVector ( for state vector of foreign updates so that server can reduce the number of udpates to send back )
+ *
+ * Notice that we do not do a step 1 sync phase here to get a state vector from the server. Reason we can avoid
+ * the 2-step sync is that we are client-server and not client-client here and we keep track of the client changes
+ * sent to server by letting server acknowledge them. There is always a chance that some client update has already
+ * been sent and that the client failed to receive the ack. However, if this happens it does not matter - the change
+ * would be sent again and Yjs handles duplicate changes anyway. And it's rare so we earn the cost of roundtrips by
+ * avoiding the step1 sync and instead keep track of this in the `unsentFrom` property of the SyncState.
+ *
+ * @param db
+ * @returns
+ */
+export declare function listYClientMessagesAndStateVector(db: DexieCloudDB, tablesToSync: Table<EntityCommon>[]): Promise<{
+    yMessages: YClientMessage[];
+    lastUpdateIds: {
+        [yTable: string]: number;
+    };
+}>;

package/dist/umd/yjs/reopenDocSignal.d.ts

@@ -0,0 +1,10 @@
+import { Subject } from "rxjs";
+import type * as Y from "yjs";
+/** A property (package-private) on Y.Doc that is used
+ * to signal that the server wants us to send a 'doc-open' message
+ * to the server for this document.
+ *
+ * @param doc
+ * @returns
+ */
+export declare function getOpenDocSignal(doc: Y.Doc): Subject<void>;

package/dist/umd/yjs/updateYSyncStates.d.ts

@@ -0,0 +1,6 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function updateYSyncStates(lastUpdateIdsBeforeSync: {
+    [yTable: string]: number;
+}, receivedUntilsAfterSync: {
+    [yTable: string]: number;
+}, db: DexieCloudDB): Promise<void>;