dexie-cloud-addon 1.0.0-alpha.6 → 1.0.0-beta.11

package/dist/types/computeSyncState.d.ts

@@ -0,0 +1,4 @@
+import { Observable } from 'rxjs';
+import { DexieCloudDB } from './db/DexieCloudDB';
+import { SyncState } from './types/SyncState';
+export declare function computeSyncState(db: DexieCloudDB): Observable<SyncState>;

package/dist/types/db/DexieCloudDB.d.ts

@@ -0,0 +1,58 @@
+import Dexie, { Table } from 'dexie';
+import { GuardedJob } from './entities/GuardedJob';
+import { UserLogin } from './entities/UserLogin';
+import { PersistedSyncState } from './entities/PersistedSyncState';
+import { DexieCloudOptions } from '../DexieCloudOptions';
+import { BehaviorSubject } from 'rxjs';
+import { BaseRevisionMapEntry } from './entities/BaseRevisionMapEntry';
+import { DBRealm, DBRealmMember, DBRealmRole, DexieCloudSchema } from 'dexie-cloud-common';
+import { BroadcastedAndLocalEvent } from '../helpers/BroadcastedAndLocalEvent';
+import { SyncStatePhase } from '../types/SyncState';
+import { MessagesFromServerConsumer } from '../sync/messagesFromServerQueue';
+export interface SyncStateChangedEventData {
+    phase: SyncStatePhase;
+    error?: Error;
+    progress?: number;
+}
+declare type SyncStateTable = Table<PersistedSyncState | DexieCloudSchema | DexieCloudOptions, 'syncState' | 'options' | 'schema'>;
+export interface DexieCloudDBBase {
+    readonly name: Dexie['name'];
+    readonly close: Dexie['close'];
+    transaction: Dexie['transaction'];
+    table: Dexie['table'];
+    readonly tables: Dexie['tables'];
+    readonly cloud: Dexie['cloud'];
+    readonly $jobs: Table<GuardedJob, string>;
+    readonly $logins: Table<UserLogin, string>;
+    readonly $syncState: SyncStateTable;
+    readonly $baseRevs: Table<BaseRevisionMapEntry, [string, number]>;
+    readonly realms: Table<DBRealm, string>;
+    readonly members: Table<DBRealmMember, string>;
+    readonly roles: Table<DBRealmRole, [string, string]>;
+    readonly localSyncEvent: BehaviorSubject<{
+        purpose?: 'pull' | 'push';
+    }>;
+    readonly syncStateChangedEvent: BroadcastedAndLocalEvent<SyncStateChangedEventData>;
+    readonly dx: Dexie;
+    readonly initiallySynced: boolean;
+}
+export interface DexieCloudDB extends DexieCloudDBBase {
+    getCurrentUser(): Promise<UserLogin>;
+    getSchema(): Promise<DexieCloudSchema | undefined>;
+    getOptions(): Promise<DexieCloudOptions | undefined>;
+    getPersistedSyncState(): Promise<PersistedSyncState | undefined>;
+    setInitiallySynced(initiallySynced: boolean): void;
+    reconfigure(): void;
+    messageConsumer: MessagesFromServerConsumer;
+}
+export declare const DEXIE_CLOUD_SCHEMA: {
+    realms: string;
+    members: string;
+    roles: string;
+    $jobs: string;
+    $syncState: string;
+    $baseRevs: string;
+    $logins: string;
+};
+export declare function DexieCloudDB(dx: Dexie): DexieCloudDB;
+export {};

package/dist/types/db/entities/BaseRevisionMapEntry.d.ts

@@ -0,0 +1,5 @@
+export interface BaseRevisionMapEntry {
+    tableName: string;
+    clientRev: number;
+    serverRev: any;
+}

package/dist/types/db/entities/EntityCommon.d.ts

@@ -0,0 +1,4 @@
+export interface EntityCommon {
+    realmId?: string;
+    owner?: string;
+}

package/dist/types/db/entities/GuardedJob.d.ts

@@ -0,0 +1,5 @@
+export interface GuardedJob {
+    nodeId: string;
+    started: Date;
+    heartbeat: Date;
+}

package/dist/types/db/entities/Member.d.ts

@@ -0,0 +1,19 @@
+export interface Member {
+    id?: string;
+    realmId: string;
+    userId?: string;
+    email?: string;
+    name?: string;
+    invite?: boolean;
+    invited?: Date;
+    accepted?: Date;
+    rejected?: Date;
+    roles?: string[];
+    permissions?: {
+        add?: string[] | "*";
+        update?: {
+            [tableName: string]: string[] | "*";
+        };
+        manage?: string[] | "*";
+    };
+}

package/dist/types/db/entities/PersistedSyncState.d.ts

@@ -0,0 +1,14 @@
+export interface PersistedSyncState {
+    serverRevision?: any;
+    latestRevisions: {
+        [tableName: string]: number;
+    };
+    realms: string[];
+    inviteRealms: string[];
+    clientIdentity: string;
+    initiallySynced?: boolean;
+    remoteDbId?: string;
+    syncedTables: string[];
+    timestamp?: Date;
+    error?: string;
+}

package/dist/types/db/entities/Realm.d.ts

@@ -0,0 +1,16 @@
+export interface Realm {
+    /** Primary key of the realm.
+     */
+    realmId: string;
+    /** The name of the realm.
+     *
+     * This property is optional but it can be a good practice to name a realm for what it represents.
+     */
+    name?: string;
+    /** Contains the user-ID of the owner. An owner has implicit full write-access to the realm
+     * and all obejcts connected to it. Ownership does not imply read (sync) access though,
+     * so realm owners still needs to add themself as a member if they are going to use the realm
+     * themselves.
+     */
+    owner?: string;
+}

package/dist/types/db/entities/Role.d.ts

@@ -0,0 +1,11 @@
+export interface Role {
+    realmId: string;
+    name: string;
+    permissions: {
+        add?: string[] | "*";
+        update?: {
+            [tableName: string]: string[] | "*";
+        };
+        manage?: string[] | "*";
+    };
+}

package/dist/types/db/entities/UserLogin.d.ts

@@ -0,0 +1,18 @@
+import { DXCUserInteraction } from "../../types/DXCUserInteraction";
+export interface UserLogin {
+    userId?: string;
+    name?: string;
+    email?: string;
+    claims: {
+        [claimName: string]: any;
+    };
+    lastLogin: Date;
+    accessToken?: string;
+    accessTokenExpiration?: Date;
+    refreshToken?: string;
+    refreshTokenExpiration?: Date;
+    nonExportablePrivateKey?: CryptoKey;
+    publicKey?: CryptoKey;
+    isLoggedIn?: boolean;
+    interaction?: DXCUserInteraction;
+}

package/dist/types/default-ui/Dialog.d.ts

@@ -0,0 +1,4 @@
+import { ComponentChildren, h } from 'preact';
+export declare function Dialog({ children }: {
+    children?: ComponentChildren;
+}): h.JSX.Element;

package/dist/types/default-ui/LoginDialog.d.ts

@@ -0,0 +1,6 @@
+import { h } from 'preact';
+import { DXCGenericUserInteraction } from '../types/DXCUserInteraction';
+import { DXCInputField } from '../types/DXCInputField';
+export declare function LoginDialog({ title, alerts, fields, onCancel, onSubmit, }: DXCGenericUserInteraction<string, {
+    [name: string]: DXCInputField;
+}>): h.JSX.Element;

package/dist/types/default-ui/Styles.d.ts

@@ -0,0 +1,3 @@
+export declare const Styles: {
+    [styleAlias: string]: Partial<CSSStyleDeclaration> | any;
+};

package/dist/types/default-ui/index.d.ts

@@ -0,0 +1,24 @@
+import Dexie from "dexie";
+import "../extend-dexie-interface";
+import { h, Component } from "preact";
+import { Subscription } from "rxjs";
+import { DXCUserInteraction } from "../types/DXCUserInteraction";
+export interface Props {
+    db: Dexie;
+}
+interface State {
+    userInteraction: DXCUserInteraction | undefined;
+}
+export default class LoginGui extends Component<Props, State> {
+    subscription?: Subscription;
+    observer: (userInteraction: DXCUserInteraction | undefined) => void;
+    constructor(props: Props);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    render(props: Props, { userInteraction }: State): h.JSX.Element | null;
+}
+export declare function setupDefaultGUI(db: Dexie): {
+    unsubscribe(): void;
+    readonly closed: boolean;
+};
+export {};

package/dist/types/dexie-cloud-client.d.ts

@@ -0,0 +1,8 @@
+import Dexie from 'dexie';
+import './extend-dexie-interface';
+export { DexieCloudTable } from './extend-dexie-interface';
+export declare function dexieCloud(dexie: Dexie): void;
+export declare namespace dexieCloud {
+    var version: string;
+}
+export default dexieCloud;

package/dist/types/errors/HttpError.d.ts

@@ -0,0 +1,5 @@
+export declare class HttpError extends Error {
+    httpStatus: number;
+    constructor(res: Response, message?: string);
+    get name(): string;
+}

package/dist/types/extend-dexie-interface.d.ts

@@ -0,0 +1,59 @@
+import { Table } from 'dexie';
+import { DexieCloudOptions } from './DexieCloudOptions';
+import { DBRealm, DBRealmMember, DBRealmRole, DexieCloudSchema } from 'dexie-cloud-common';
+import { UserLogin } from './db/entities/UserLogin';
+import * as Rx from 'rxjs';
+import { PersistedSyncState } from './db/entities/PersistedSyncState';
+import { SyncState } from './types/SyncState';
+import { DexieCloudServerState } from './DexieCloudServerState';
+import { EntityCommon } from './db/entities/EntityCommon';
+import { DXCUserInteraction } from './types/DXCUserInteraction';
+import { DXCWebSocketStatus } from './DXCWebSocketStatus';
+export interface DexieCloudSyncOptions {
+    wait: boolean;
+    purpose: "push" | "pull";
+}
+export declare type DexieCloudTable<T = any> = Table<T & EntityCommon, string>;
+declare module 'dexie' {
+    interface Dexie {
+        cloud: {
+            version: string;
+            options: DexieCloudOptions | null;
+            schema: DexieCloudSchema | null;
+            serverState: DexieCloudServerState | null;
+            currentUserId: string;
+            currentUser: Rx.BehaviorSubject<UserLogin>;
+            webSocketStatus: Rx.BehaviorSubject<DXCWebSocketStatus>;
+            syncState: Rx.BehaviorSubject<SyncState>;
+            persistedSyncState: Rx.BehaviorSubject<PersistedSyncState | undefined>;
+            userInteraction: Rx.BehaviorSubject<DXCUserInteraction | undefined>;
+            usingServiceWorker?: boolean;
+            /** Login using Dexie Cloud OTP or Demo user.
+             *
+             * @param email Email to authenticate
+             */
+            login(hint?: {
+                email?: string;
+                userId?: string;
+                grant_type?: 'demo' | 'otp';
+            }): Promise<void>;
+            /**
+             * Connect to given URL
+             */
+            configure(options: DexieCloudOptions): void;
+            /** Wait until a full sync is done.
+             *
+             */
+            sync(options?: DexieCloudSyncOptions): Promise<void>;
+        };
+        realms: Table<Partial<DBRealm>, string>;
+        members: Table<Partial<DBRealmMember>, string>;
+        roles: Table<DBRealmRole, [string, string]>;
+    }
+    interface DexieConstructor {
+        Cloud: {
+            (db: Dexie): void;
+            version: string;
+        };
+    }
+}

package/dist/types/helpers/BroadcastedAndLocalEvent.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { SWBroadcastChannel } from "./SWBroadcastChannel";
+export declare class BroadcastedAndLocalEvent<T> extends Observable<T> {
+    name: string;
+    bc: BroadcastChannel | SWBroadcastChannel;
+    constructor(name: string);
+    next(message: T): void;
+}

package/dist/types/helpers/BroadcastedLocalEvent.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { SWBroadcastChannel } from "./SWBroadcastChannel";
+export declare class BroadcastedAndLocalEvent<T> extends Observable<T> {
+    name: string;
+    bc: BroadcastChannel | SWBroadcastChannel;
+    constructor(name: string);
+    next(message: T): void;
+}

package/dist/types/helpers/CancelToken.d.ts

@@ -0,0 +1,4 @@
+export interface CancelToken {
+    cancelled: boolean;
+}
+export declare function throwIfCancelled(cancelToken?: CancelToken): void;

package/dist/types/helpers/IS_SERVICE_WORKER.d.ts

@@ -0,0 +1 @@
+export declare const IS_SERVICE_WORKER: false;

package/dist/types/helpers/SWBroadcastChannel.d.ts

@@ -0,0 +1,6 @@
+export declare class SWBroadcastChannel {
+    name: string;
+    constructor(name: string);
+    subscribe(listener: (message: any) => void): () => void;
+    postMessage(message: any): void;
+}

package/dist/types/helpers/allSettled.d.ts

@@ -0,0 +1 @@
+export declare function allSettled(possiblePromises: any[]): Promise<unknown>;

package/dist/types/helpers/bulkUpdate.d.ts

@@ -0,0 +1,4 @@
+import { Table } from 'dexie';
+export declare function bulkUpdate(table: Table, keys: any[], changeSpecs: {
+    [keyPath: string]: any;
+}[]): Promise<void>;

package/dist/types/helpers/computeRealmSetHash.d.ts

@@ -0,0 +1,2 @@
+import { PersistedSyncState } from '../db/entities/PersistedSyncState';
+export declare function computeRealmSetHash({ realms, inviteRealms, }: PersistedSyncState): Promise<string>;

package/dist/types/helpers/date-constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SECONDS = 1000;
+export declare const MINUTES: number;
+export declare const HOURS: number;
+export declare const DAYS: number;
+export declare const WEEKS: number;

package/dist/types/helpers/dbOnClosed.d.ts

@@ -0,0 +1,2 @@
+import Dexie from "dexie";
+export declare function dbOnClosed(db: Dexie, handler: () => void): () => void;

package/dist/types/helpers/getMutationTable.d.ts

@@ -0,0 +1 @@
+export declare function getMutationTable(tableName: string): string;

package/dist/types/helpers/getSyncableTables.d.ts

@@ -0,0 +1,4 @@
+import { Table } from "dexie";
+import { DexieCloudDB } from "../db/DexieCloudDB";
+import { EntityCommon } from "../db/entities/EntityCommon";
+export declare function getSyncableTables(db: DexieCloudDB): Table<EntityCommon>[];

package/dist/types/helpers/getTableFromMutationTable.d.ts

@@ -0,0 +1 @@
+export declare function getTableFromMutationTable(mutationTable: string): string;

package/dist/types/helpers/makeArray.d.ts

@@ -0,0 +1 @@
+export declare function makeArray<T>(iterable: Iterable<T>): T[];

package/dist/types/helpers/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(bytes: number): string;

package/dist/types/helpers/resolveText.d.ts

@@ -0,0 +1,2 @@
+import { DXCAlert } from "../types/DXCAlert";
+export declare function resolveText({ message, messageCode, messageParams }: DXCAlert): string;

package/dist/types/helpers/throwVersionIncrementNeeded.d.ts

@@ -0,0 +1 @@
+export declare function throwVersionIncrementNeeded(): void;

package/dist/types/helpers/visibilityState.d.ts

@@ -0,0 +1 @@
+export declare function createVisibilityStateObservable(): import("rxjs").Observable<VisibilityState>;

package/dist/types/helpers/visibleState.d.ts

@@ -0,0 +1 @@
+export declare function getVisibilityStateObservable(): import("rxjs").Observable<VisibilityState>;

package/dist/types/isFirefox.d.ts

@@ -0,0 +1 @@
+export declare const isFirefox: boolean;

package/dist/types/isSafari.d.ts

@@ -0,0 +1,2 @@
+export declare const isSafari: boolean;
+export declare const safariVersion: number;

package/dist/types/middleware-helpers/guardedTable.d.ts

@@ -0,0 +1,11 @@
+import { DBCoreTable } from "dexie";
+export declare function guardedTable(table: DBCoreTable): {
+    count: (req: import("dexie").DBCoreCountRequest) => Promise<number>;
+    get: (req: import("dexie").DBCoreGetRequest) => Promise<any>;
+    getMany: (req: import("dexie").DBCoreGetManyRequest) => Promise<any[]>;
+    openCursor: (req: import("dexie").DBCoreOpenCursorRequest) => Promise<import("dexie").DBCoreCursor | null>;
+    query: (req: import("dexie").DBCoreQueryRequest) => Promise<import("dexie").DBCoreQueryResponse>;
+    mutate: (req: import("dexie").DBCoreMutateRequest) => Promise<import("dexie").DBCoreMutateResponse>;
+    name: string;
+    schema: import("dexie").DBCoreTableSchema;
+};

package/dist/types/middlewares/createIdGenerationMiddleware.d.ts

@@ -0,0 +1,8 @@
+import { DBCore, DBCoreAddRequest, DBCoreDeleteRequest, DBCoreIndex, DBCorePutRequest, Middleware } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function toStringTag(o: Object): any;
+export declare function getEffectiveKeys(primaryKey: DBCoreIndex, req: (Pick<DBCoreAddRequest | DBCorePutRequest, 'type' | 'values'> & {
+    keys?: any[];
+}) | Pick<DBCoreDeleteRequest, 'keys' | 'type'>): any[];
+export declare function generateTablePrefix(tableName: string, allPrefixes: Set<string>): string;
+export declare function createIdGenerationMiddleware(db: DexieCloudDB): Middleware<DBCore>;

package/dist/types/middlewares/createImplicitPropSetterMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { DBCore, Middleware } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createImplicitPropSetterMiddleware(db: DexieCloudDB): Middleware<DBCore>;

package/dist/types/middlewares/createMutationTrackingMiddleware.d.ts

@@ -0,0 +1,17 @@
+import { DBCore, Middleware } from 'dexie';
+import { BehaviorSubject } from 'rxjs';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { UserLogin } from '../db/entities/UserLogin';
+export interface MutationTrackingMiddlewareArgs {
+    currentUserObservable: BehaviorSubject<UserLogin>;
+    db: DexieCloudDB;
+}
+/** Tracks all mutations in the same transaction as the mutations -
+ * so it is guaranteed that no mutation goes untracked - and if transaction
+ * aborts, the mutations won't be tracked.
+ *
+ * The sync job will use the tracked mutations as the source of truth when pushing
+ * changes to server and cleanup the tracked mutations once the server has
+ * ackowledged that it got them.
+ */
+export declare function createMutationTrackingMiddleware({ currentUserObservable, db }: MutationTrackingMiddlewareArgs): Middleware<DBCore>;

package/dist/types/middlewares/outstandingTransaction.d.ts

@@ -0,0 +1,4 @@
+import { DBCoreTransaction } from 'dexie';
+import { BehaviorSubject } from 'rxjs';
+import { TXExpandos } from '../types/TXExpandos';
+export declare const outstandingTransactions: BehaviorSubject<Set<DBCoreTransaction & IDBTransaction & TXExpandos>>;

package/dist/types/overrideParseStoresSpec.d.ts

@@ -0,0 +1,4 @@
+import Dexie, { DbSchema } from 'dexie';
+export declare function overrideParseStoresSpec(origFunc: Function, dexie: Dexie): (stores: {
+    [tableName: string]: string;
+}, dbSchema: DbSchema) => any;

package/dist/types/performInitialSync.d.ts

@@ -0,0 +1,4 @@
+import { DexieCloudSchema } from 'dexie-cloud-common';
+import { DexieCloudDB } from './db/DexieCloudDB';
+import { DexieCloudOptions } from './DexieCloudOptions';
+export declare function performInitialSync(db: DexieCloudDB, cloudOptions: DexieCloudOptions, cloudSchema: DexieCloudSchema): Promise<void>;

package/dist/types/service-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/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/types/sync/SyncRequiredError.d.ts

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

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

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

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

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

package/dist/types/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/types/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, import("dexie").IndexableType>[];

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

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

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

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

package/dist/types/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/types/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/types/sync/messageConsumerIsReady.d.ts

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

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

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

package/dist/types/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/types/sync/myId.d.ts

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

package/dist/types/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/types/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/types/sync/performGuardedJob.d.ts

@@ -0,0 +1,4 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function performGuardedJob(db: DexieCloudDB, jobName: string, jobsTableName: string, job: () => Promise<any>, { awaitRemoteJob }?: {
+    awaitRemoteJob?: boolean;
+}): Promise<void>;

package/dist/types/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/types/sync/sync.d.ts

@@ -0,0 +1,17 @@
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { DexieCloudOptions } from '../DexieCloudOptions';
+import { DBOperationsSet, DexieCloudSchema } from 'dexie-cloud-common';
+export declare const CURRENT_SYNC_WORKER = "currentSyncWorker";
+export declare let numberOfSyncRequests: number;
+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 applyServerChanges(changes: DBOperationsSet, db: DexieCloudDB): Promise<void>;
+export declare function filterServerChangesThroughAddedClientChanges(serverChanges: DBOperationsSet, addedClientChanges: DBOperationsSet): DBOperationsSet;