@wells-nelson/data-storage 0.0.0-stage → 0.0.1

package/README.md

@@ -1,3 +1,80 @@
-# Temporary Holding Version
+# @wells-nelson/data-storage
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Offline-first storage for apps whose data lives in **containers** (a project, a list) that hold
+every other row and are what gets shared. Local data is always on the device; signed-in users
+also get a per-user cloud database replicated to Supabase.
+
+Peer dependencies: `svelte`, `rxdb`, `rxjs`, `@tanstack/db`, `@tanstack/rxdb-db-collection`,
+`@supabase/supabase-js`. Keep `"overrides": { "rxdb": "$rxdb" }` in the app.
+
+## Set up
+
+```ts
+// src/lib/store.ts
+import { createSyncedStore, envConfig, field, flatSchema } from '@wells-nelson/data-storage';
+import { getRxStorageDexie } from 'rxdb/plugins/storage-dexie';
+
+// Pass the container collection as the second type argument so its rows are typed precisely.
+export const store = createSyncedStore<Docs, 'projects'>({
+	appKey: 'demo', // demo_local, demo_cloud_<user>, demo:hidden, demo:sync:<user>, demo:defaultProject…
+	nouns: { singular: 'project', plural: 'projects' },
+	env: envConfig(import.meta.env),
+	storage: getRxStorageDexie,
+	roles: true,
+	collections: ['projects', 'tasks', 'task_links', 'notes'], // parents first
+	schemas, // flatSchema<ProjectDoc>({ id: field.id, name: field.string, … }) per collection
+	container: 'projects',
+	containerField: 'project_id',
+	indexContainerField: true,
+	// Ids of other rows in the container, rewritten when a copy gets new ids.
+	refs: { task_links: ['from_id', 'to_id'] },
+	// Composite ids and ids inside text fields (runs after `refs` were mapped).
+	remap: (collection, row, map) => {
+		if (collection === 'task_links') return { ...row, id: `${row.from_id}:${row.to_id}` };
+		if (collection === 'notes') return { ...row, mentions: row.mentions.split(',').map(map).join(',') };
+		return row;
+	}
+});
+```
+
+```ts
+// root layout
+onMount(() => void store.init({ beforeReady: importDevSeed }));
+```
+
+`store` holds:
+
+- `app`: `local` / `cloud` data sets (`DataSet`: the RxDB database plus a TanStack DB
+  collection per RxDB collection), `ready`, `fatal`.
+- `cloud`: `CloudSync`: session (Google, email link), replication, `pendingIds`, `hasPending`,
+  `lastSync`, `online`, `active`, `error`, `rejectedWrite`, `roleOf`, `revokedIds`,
+  `forceResync`, `signOut`.
+- `ops`: container operations (`createContainer`, `renameContainer`, `makeCloud`, `makeLocal`,
+  `deleteContainer`, `leaveContainer`, `keepRevokedCopy`, `removeRevoked`, `entries`) and the row
+  helpers they're built from (`insertDoc`, `patch`, `removeDocs`, `docsWhere`, `touch`…).
+- `supabase`: lazy PKCE client and members API (`fetchMembers`, `inviteMember`, `setMemberRole`,
+  `removeMember`, `leave`, `fetchMyMemberships`) with friendly error messages.
+- `tombstones`: hides deleted rows at once and keeps hiding them if a sync briefly restores
+  them; pruned after a week.
+- `prefs`: `DevicePrefs` (default container, "already prompted", collapsed sections). Pass a
+  subclass as `prefs` for app-specific ones and override `replaceContainer` to keep them in step.
+- `resetDevice()`: teardown for a dev wipe.
+
+Without roles everyone is an owner. Table and RPC names default to `<noun>_members` and
+`get_<noun>_members`; override with e.g. `members: { membersRpc: 'get_list_collaborators' }`.
+
+## SQL migration
+
+```ts
+import { generateMigration, tablesFromSchemas } from '@wells-nelson/data-storage/sql';
+
+const sql = generateMigration({
+	container: 'projects',
+	containerField: 'project_id',
+	noun: 'project',
+	roles: true,
+	tables: tablesFromSchemas(collections, schemas, { containerField: 'project_id', refs, defaults: { tasks: { done: 'false' } } })
+});
+```
+
+The sandbox's Data storage page runs this store in the browser and shows the migration.

package/dist/app.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { DataSet } from './dataset.js';
+import type { DocMap, Location } from './types.js';
+/**
+ * Holds the two data sets: `local` (this device only, never synced) is always open;
+ * `cloud` exists only while signed in and replicates to Supabase.
+ */
+export declare class AppState<D extends DocMap> {
+    local: DataSet<D> | null;
+    cloud: DataSet<D> | null;
+    ready: boolean;
+    fatal: string | null;
+    dataSet(location: Location): DataSet<D>;
+}

package/dist/app.svelte.js

@@ -0,0 +1,16 @@
+/**
+ * Holds the two data sets: `local` (this device only, never synced) is always open;
+ * `cloud` exists only while signed in and replicates to Supabase.
+ */
+export class AppState {
+    local = $state.raw(null);
+    cloud = $state.raw(null);
+    ready = $state(false);
+    fatal = $state(null);
+    dataSet(location) {
+        const ds = location === 'local' ? this.local : this.cloud;
+        if (!ds)
+            throw new Error(`The ${location} data set is not available`);
+        return ds;
+    }
+}

package/dist/cloud.svelte.d.ts

@@ -0,0 +1,68 @@
+import type { User } from '@supabase/supabase-js';
+import type { AppState } from './app.svelte.js';
+import { type StorageFactory } from './database.js';
+import type { SupabaseApi } from './supabase.js';
+import { type DocMap, type Role, type StoreSchema } from './types.js';
+/** Push errors caused by the server refusing the write (RLS, triggers), not by connectivity. */
+export declare function isRejection(err: unknown): boolean;
+export declare function errorMessage(err: unknown): string;
+export interface CloudSyncOptions<D extends DocMap> {
+    /** Prefix for database names and localStorage keys, e.g. 'demo'. */
+    appKey: string;
+    schema: StoreSchema<D>;
+    app: AppState<D>;
+    supabase: SupabaseApi;
+    /** Containers have viewer / editor / owner roles. Without roles everyone is an owner. */
+    roles?: boolean;
+    storage?: StorageFactory;
+}
+/**
+ * Supabase session, the per-user cloud database and its live replication, and sync status:
+ * pending changes per container (cleared once replication settles), last sync time, blocked
+ * containers, membership / revocation checks, cached roles and rejected writes.
+ */
+export declare class CloudSync<D extends DocMap> {
+    #private;
+    readonly configured: boolean;
+    user: User | null;
+    /** Supabase dropped the session on its own (e.g. refresh token revoked); data is kept until sign-in. */
+    sessionExpired: boolean;
+    online: boolean;
+    active: boolean;
+    error: string | null;
+    /**
+     * A write the server rejected (e.g. a permission or last-owner rule). Unlike transient
+     * network errors this needs the user's attention; show it until dismissed.
+     */
+    rejectedWrite: string | null;
+    constructor(options: CloudSyncOptions<D>);
+    get email(): string;
+    get lastSync(): number | null;
+    /** Containers with local changes that haven't reached Supabase yet. */
+    get pendingIds(): string[];
+    get hasAnyPending(): boolean;
+    hasPending(containerId: string): boolean;
+    isRevoked(containerId: string): boolean;
+    get revokedIds(): string[];
+    /**
+     * This user's role on a cloud container. A container created here that hasn't synced yet is
+     * ours. Without roles everyone is an owner.
+     */
+    roleOf(containerId: string): Role;
+    /** Record our role right away (e.g. after creating a container or changing roles). */
+    setRole(containerId: string, role: Role): void;
+    init(): Promise<void>;
+    /** Record that a container has local changes that still need to reach Supabase. */
+    markPending(containerId: string): void;
+    clearPending(containerId: string): void;
+    /** Stop pushing anything for this container (used right before removing it from this device). */
+    block(containerId: string): void;
+    /** Detect cloud containers this user no longer has access to (someone unshared them). */
+    checkMemberships(force?: boolean): Promise<void>;
+    forceResync(): Promise<void>;
+    signInWithGoogle(redirectTo: string): Promise<void>;
+    /** Email a magic sign-in link. The link has to be opened in this browser (PKCE). */
+    signInWithEmail(email: string, redirectTo: string): Promise<void>;
+    /** Removes every cloud-enabled container from this device. Local-only ones stay. */
+    signOut(): Promise<void>;
+}

package/dist/cloud.svelte.js

@@ -0,0 +1,349 @@
+import { replicateSupabase } from 'rxdb/plugins/replication-supabase';
+import { tick } from 'svelte';
+import { openDatabase } from './database.js';
+import { createDataSet, disposeDataSet } from './dataset.js';
+import { Persisted } from './persisted.svelte.js';
+import { containerIdOf } from './types.js';
+const emptyState = () => ({ pending: {}, blocked: [], revoked: [], roles: {}, lastSync: null });
+const MEMBERSHIP_CHECK_INTERVAL = 30_000;
+/** Push errors caused by the server refusing the write (RLS, triggers), not by connectivity. */
+export function isRejection(err) {
+    const e = err;
+    if (e?.parameters?.direction !== 'push')
+        return false;
+    const code = e.parameters.errors?.[0]?.code;
+    // 42501: RLS violation; P0001: raised by a trigger (e.g. last owner); 23xxx: constraint violations.
+    return !!code && (code === '42501' || code === 'P0001' || code.startsWith('23'));
+}
+export function errorMessage(err) {
+    if (err && typeof err === 'object') {
+        const e = err;
+        return e.parameters?.errors?.[0]?.message ?? e.message ?? String(err);
+    }
+    return String(err);
+}
+/**
+ * Supabase session, the per-user cloud database and its live replication, and sync status:
+ * pending changes per container (cleared once replication settles), last sync time, blocked
+ * containers, membership / revocation checks, cached roles and rejected writes.
+ */
+export class CloudSync {
+    configured;
+    user = $state.raw(null);
+    /** Supabase dropped the session on its own (e.g. refresh token revoked); data is kept until sign-in. */
+    sessionExpired = $state(false);
+    online = $state(typeof navigator === 'undefined' ? true : navigator.onLine);
+    active = $state(false);
+    error = $state(null);
+    /**
+     * A write the server rejected (e.g. a permission or last-owner rule). Unlike transient
+     * network errors this needs the user's attention; show it until dismissed.
+     */
+    rejectedWrite = $state(null);
+    #appKey;
+    #schema;
+    #app;
+    #sb;
+    #roles;
+    #storage;
+    #state;
+    #replications = [];
+    #subscriptions = [];
+    #activeReps = new Set();
+    #writeVersion = 0;
+    #settling = false;
+    #resettle = false;
+    #settleTimer;
+    #lastMembershipCheck = 0;
+    #signingOut = false;
+    #queue = Promise.resolve();
+    constructor(options) {
+        this.#appKey = options.appKey;
+        this.#schema = options.schema;
+        this.#app = options.app;
+        this.#sb = options.supabase;
+        this.#roles = options.roles ?? false;
+        this.#storage = options.storage;
+        this.configured = options.supabase.configured;
+        this.#state = new Persisted(this.#stateKey('anonymous'), emptyState());
+    }
+    #stateKey(userId) {
+        return `${this.#appKey}:sync:${userId}`;
+    }
+    get email() {
+        return this.user?.email?.toLowerCase() ?? '';
+    }
+    get lastSync() {
+        return this.#state.value.lastSync;
+    }
+    /** Containers with local changes that haven't reached Supabase yet. */
+    get pendingIds() {
+        return Object.keys(this.#state.value.pending);
+    }
+    get hasAnyPending() {
+        return this.pendingIds.length > 0;
+    }
+    hasPending(containerId) {
+        return containerId in this.#state.value.pending;
+    }
+    isRevoked(containerId) {
+        return this.#state.value.revoked.includes(containerId);
+    }
+    get revokedIds() {
+        return this.#state.value.revoked;
+    }
+    /**
+     * This user's role on a cloud container. A container created here that hasn't synced yet is
+     * ours. Without roles everyone is an owner.
+     */
+    roleOf(containerId) {
+        if (!this.#roles)
+            return 'owner';
+        const role = this.#state.value.roles[containerId];
+        if (role)
+            return role;
+        return this.hasPending(containerId) ? 'owner' : 'viewer';
+    }
+    /** Record our role right away (e.g. after creating a container or changing roles). */
+    setRole(containerId, role) {
+        if (this.#roles)
+            this.#update((s) => (s.roles[containerId] = role));
+    }
+    async init() {
+        if (typeof window !== 'undefined') {
+            window.addEventListener('online', () => {
+                this.online = true;
+                for (const rep of this.#replications)
+                    rep.reSync();
+                this.#scheduleSettle();
+            });
+            window.addEventListener('offline', () => (this.online = false));
+        }
+        const sb = this.#sb.getClient();
+        if (!sb)
+            return;
+        const { data } = await sb.auth.getSession();
+        if (data.session)
+            await this.#serial(() => this.#startFor(data.session.user));
+        sb.auth.onAuthStateChange((event, session) => {
+            // Supabase recommends not awaiting other calls inside this callback.
+            setTimeout(() => {
+                if (session?.user && session.user.id !== this.user?.id) {
+                    void this.#serial(() => this.#startFor(session.user));
+                }
+                else if (session?.user) {
+                    this.user = session.user;
+                    this.sessionExpired = false;
+                }
+                else if (event === 'SIGNED_OUT' && this.user && !this.#signingOut) {
+                    this.sessionExpired = true;
+                }
+            });
+        });
+    }
+    #serial(fn) {
+        const next = this.#queue.then(fn, fn);
+        this.#queue = next.catch(() => undefined);
+        return next;
+    }
+    async #startFor(user) {
+        if (this.user?.id === user.id && this.#app.cloud) {
+            this.user = user;
+            this.sessionExpired = false;
+            return;
+        }
+        if (this.user)
+            await this.#teardown(false);
+        this.#state.rekey(this.#stateKey(user.id), emptyState());
+        this.#writeVersion = Math.max(0, ...Object.values(this.#state.value.pending));
+        const db = await openDatabase(`${this.#appKey}_cloud_${user.id.replace(/[^a-z0-9]/gi, '').toLowerCase()}`, this.#schema, { storage: this.#storage });
+        this.user = user;
+        this.sessionExpired = false;
+        this.#app.cloud = createDataSet('cloud', db, this.#schema);
+        this.#startReplication(db);
+        this.#scheduleSettle();
+    }
+    #startReplication(db) {
+        const sb = this.#sb.getClient();
+        this.#schema.collections.forEach((name, index) => {
+            const rep = replicateSupabase({
+                replicationIdentifier: `supabase-${name}`,
+                client: sb,
+                tableName: name,
+                collection: db.collections[name],
+                live: true,
+                waitForLeadership: false,
+                retryTime: 10_000,
+                autoStart: true,
+                pull: { batchSize: 200 },
+                push: {
+                    batchSize: 50,
+                    modifier: (doc) => this.#state.value.blocked.includes(containerIdOf(this.#schema, name, doc)) ? null : doc
+                }
+            });
+            this.#replications.push(rep);
+            this.#subscriptions.push(rep.error$.subscribe((err) => {
+                this.error = errorMessage(err);
+                if (isRejection(err))
+                    this.rejectedWrite = this.error;
+            }), rep.active$.subscribe((isActive) => {
+                if (isActive)
+                    this.#activeReps.add(index);
+                else
+                    this.#activeReps.delete(index);
+                this.active = this.#activeReps.size > 0;
+            }), rep.received$.subscribe(() => this.#scheduleSettle()), rep.sent$.subscribe(() => this.#scheduleSettle()));
+        });
+    }
+    async #teardown(removeData) {
+        clearTimeout(this.#settleTimer);
+        for (const sub of this.#subscriptions)
+            sub.unsubscribe();
+        this.#subscriptions = [];
+        const reps = this.#replications;
+        this.#replications = [];
+        this.#activeReps.clear();
+        this.active = false;
+        await Promise.allSettled(reps.map((r) => r.cancel()));
+        const ds = this.#app.cloud;
+        this.#app.cloud = null;
+        if (ds) {
+            // Let the UI drop its live queries on these collections before cleaning them up;
+            // cleaning up a collection a live query still depends on is TanStack DB error 254.
+            await tick();
+            await new Promise((r) => setTimeout(r, 0));
+            await disposeDataSet(ds, this.#schema.collections).catch((err) => console.warn('Collection cleanup failed', err));
+            if (removeData)
+                await ds.db.remove();
+            else
+                await ds.db.close();
+        }
+        if (removeData && this.user)
+            Persisted.remove(this.#stateKey(this.user.id));
+        this.#state.rekey(this.#stateKey('anonymous'), emptyState());
+        this.user = null;
+        this.error = null;
+    }
+    #update(fn) {
+        const next = $state.snapshot(this.#state.value);
+        fn(next);
+        this.#state.value = next;
+    }
+    /** Record that a container has local changes that still need to reach Supabase. */
+    markPending(containerId) {
+        const version = ++this.#writeVersion;
+        this.#update((s) => (s.pending[containerId] = version));
+        this.#scheduleSettle();
+    }
+    clearPending(containerId) {
+        this.#update((s) => delete s.pending[containerId]);
+    }
+    /** Stop pushing anything for this container (used right before removing it from this device). */
+    block(containerId) {
+        this.#update((s) => {
+            if (!s.blocked.includes(containerId))
+                s.blocked.push(containerId);
+            delete s.pending[containerId];
+            s.revoked = s.revoked.filter((id) => id !== containerId);
+        });
+    }
+    #scheduleSettle() {
+        clearTimeout(this.#settleTimer);
+        this.#settleTimer = setTimeout(() => void this.#settle(), 300);
+    }
+    /** Waits until every replication is idle, then clears pending changes made before the wait began. */
+    async #settle() {
+        if (this.#settling) {
+            this.#resettle = true;
+            return;
+        }
+        this.#settling = true;
+        try {
+            do {
+                this.#resettle = false;
+                const reps = this.#replications;
+                if (reps.length === 0)
+                    return;
+                const version = this.#writeVersion;
+                await Promise.all(reps.map((r) => r.awaitInSync()));
+                if (reps !== this.#replications)
+                    return;
+                this.#update((s) => {
+                    for (const [id, v] of Object.entries(s.pending))
+                        if (v <= version)
+                            delete s.pending[id];
+                    s.lastSync = Date.now();
+                });
+                this.error = null;
+                void this.checkMemberships();
+            } while (this.#resettle);
+        }
+        finally {
+            this.#settling = false;
+        }
+    }
+    /** Detect cloud containers this user no longer has access to (someone unshared them). */
+    async checkMemberships(force = false) {
+        const ds = this.#app.cloud;
+        if (!ds || !this.online || !this.email)
+            return;
+        if (!force && Date.now() - this.#lastMembershipCheck < MEMBERSHIP_CHECK_INTERVAL)
+            return;
+        this.#lastMembershipCheck = Date.now();
+        try {
+            const memberOf = await this.#sb.fetchMyMemberships(this.email);
+            const containers = await ds.db.collections[this.#schema.container].find().exec();
+            if (ds !== this.#app.cloud)
+                return;
+            this.#update((s) => {
+                if (this.#roles) {
+                    s.roles = Object.fromEntries([...memberOf].filter((e) => e[1] !== null));
+                }
+                s.revoked = containers
+                    .map((c) => c.primary)
+                    .filter((id) => !memberOf.has(id) && !(id in s.pending) && !s.blocked.includes(id));
+                // A container that was re-shared becomes pushable again.
+                s.blocked = s.blocked.filter((id) => !memberOf.has(id));
+            });
+        }
+        catch (err) {
+            this.error = errorMessage(err);
+        }
+    }
+    async forceResync() {
+        for (const rep of this.#replications)
+            rep.reSync();
+        this.#scheduleSettle();
+        await this.checkMemberships(true);
+    }
+    async signInWithGoogle(redirectTo) {
+        const sb = this.#sb.getClient();
+        if (!sb)
+            throw new Error('Cloud sync is not configured.');
+        const { error } = await sb.auth.signInWithOAuth({ provider: 'google', options: { redirectTo } });
+        if (error)
+            throw error;
+    }
+    /** Email a magic sign-in link. The link has to be opened in this browser (PKCE). */
+    async signInWithEmail(email, redirectTo) {
+        const sb = this.#sb.getClient();
+        if (!sb)
+            throw new Error('Cloud sync is not configured.');
+        const { error } = await sb.auth.signInWithOtp({ email: email.trim(), options: { emailRedirectTo: redirectTo } });
+        if (error)
+            throw error;
+    }
+    /** Removes every cloud-enabled container from this device. Local-only ones stay. */
+    async signOut() {
+        const sb = this.#sb.getClient();
+        this.#signingOut = true;
+        try {
+            await this.#serial(() => this.#teardown(true));
+            this.sessionExpired = false;
+            await sb?.auth.signOut({ scope: 'local' });
+        }
+        finally {
+            this.#signingOut = false;
+        }
+    }
+}

package/dist/containers.d.ts

@@ -0,0 +1,74 @@
+import type { RxCollection } from 'rxdb/plugins/core';
+import type { AppState } from './app.svelte.js';
+import type { CloudSync } from './cloud.svelte.js';
+import type { DataSet } from './dataset.js';
+import type { DevicePrefs } from './prefs.svelte.js';
+import type { SupabaseApi } from './supabase.js';
+import type { Tombstones } from './tombstones.svelte.js';
+import type { CollectionName, DocMap, Location, Role, StoreSchema } from './types.js';
+/** Every row of one container, by collection. */
+export type ContainerDocs<D extends DocMap> = {
+    [N in CollectionName<D>]: D[N][];
+};
+/**
+ * App-specific id references a copy has to rewrite, beyond `id`, the container field and the
+ * `refs` fields: composite ids and ids inside text fields. `map` turns an old id into the copy's
+ * id (the identity when ids are kept).
+ */
+export type RemapHook<D extends DocMap> = <N extends CollectionName<D>>(collection: N, row: D[N], map: (id: string) => string) => D[N];
+export interface ContainerOpsOptions<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> {
+    schema: StoreSchema<D, C>;
+    app: AppState<D>;
+    cloud: CloudSync<D>;
+    tombstones: Tombstones;
+    prefs: DevicePrefs;
+    supabase: SupabaseApi;
+    roles?: boolean;
+    /** Fields per collection holding ids of other rows in the same container, e.g. `{ items: ['category_id'] }`. */
+    refs?: {
+        [N in CollectionName<D>]?: (keyof D[N] & string)[];
+    };
+    remap?: RemapHook<D>;
+}
+/** A container as listed by the app (one entry even while it moves between data sets). */
+export interface ContainerEntry<T> {
+    container: T;
+    location: Location;
+    role: Role;
+}
+/** Persisting a TanStack DB transaction in the background, logging failures. */
+export declare function persist(tx: {
+    when(state: 'settled'): Promise<unknown>;
+}): void;
+export declare const now: () => number;
+export declare const uid: () => `${string}-${string}-${string}-${string}-${string}`;
+export type ContainerOps<D extends DocMap, C extends CollectionName<D> = CollectionName<D>> = ReturnType<typeof createContainerOps<D, C>>;
+/**
+ * Operations on whole containers and the low-level row helpers they're built from. Every write
+ * to a cloud data set marks the container pending so the profile can show unsynced changes.
+ */
+export declare function createContainerOps<D extends DocMap, C extends CollectionName<D> = CollectionName<D>>(options: ContainerOpsOptions<D, C>): {
+    rx: <N extends CollectionName<D>>(ds: DataSet<D>, name: N) => RxCollection<D[N]>;
+    touch: (ds: DataSet<D>, containerId: string) => void;
+    removeDocs: <N extends CollectionName<D>>(ds: DataSet<D>, name: N, ids: string[]) => Promise<void>;
+    docsWhere: <N extends CollectionName<D>>(ds: DataSet<D>, name: N, selector: Partial<Record<keyof D[N] & string, string | number | boolean>>) => Promise<D[N][]>;
+    insertDoc: <N extends CollectionName<D>>(ds: DataSet<D>, name: N, doc: D[N], containerId: string) => void;
+    patch: <N extends CollectionName<D>>(ds: DataSet<D>, name: N, id: string, containerId: string, fields: Partial<D[N]>) => void;
+    createContainer: (ds: DataSet<D>, fields: Omit<D[C], "id" | "updated_at" | "created_at">) => string;
+    renameContainer: (ds: DataSet<D>, containerId: string, name: string) => void;
+    readContainer: (ds: DataSet<D>, containerId: string) => Promise<ContainerDocs<D>>;
+    removeContainerDocs: (ds: DataSet<D>, containerId: string) => Promise<void>;
+    insertContainerDocs: (to: DataSet<D>, docs: Partial<ContainerDocs<D>>) => Promise<void>;
+    remapContainer: (docs: ContainerDocs<D>, containerId: string, newIds: boolean) => {
+        rows: ContainerDocs<D>;
+        containerId: string;
+    };
+    copyContainer: (from: DataSet<D>, to: DataSet<D>, containerId: string, newIds: boolean) => Promise<string>;
+    makeCloud: (containerId: string) => Promise<void>;
+    makeLocal: (containerId: string) => Promise<string>;
+    deleteContainer: (ds: DataSet<D>, containerId: string) => Promise<void>;
+    leaveContainer: (containerId: string) => Promise<void>;
+    keepRevokedCopy: (containerId: string) => Promise<string>;
+    removeRevoked: (containerId: string) => Promise<void>;
+    entries: (localRows: D[C][], cloudRows: D[C][]) => ContainerEntry<D[C]>[];
+};