@estra/client 0.0.0-stage → 0.1.1

package/dist/offline.js

@@ -0,0 +1,309 @@
+import { applyWrite, getPath, inCollection, runLocal } from "./local.js";
+import { memoryStore } from "./store.js";
+import { EstraClientError } from "./transport.js";
+const isOffline = (e) => (e instanceof EstraClientError && e.code === "unavailable") || e instanceof TypeError;
+const unavailable = (m) => new EstraClientError("unavailable", m);
+const pad = (n) => String(n).padStart(12, "0");
+export function offline(inner, o = {}) {
+    const store = o.store ?? memoryStore();
+    const docs = new Map();
+    let pending = [];
+    const waiters = new Map();
+    const settled = new Map();
+    const listeners = new Set();
+    let nextSeq = 1;
+    let network = true;
+    let flushing = null;
+    let retryTimer = null;
+    let backoff = o.retryMs ?? 1000;
+    let ready = null;
+    const init = () => (ready ??= (async () => {
+        for (const [, d] of await store.list("d:"))
+            docs.set(d.path, d);
+        pending = (await store.list("p:")).map(([, e]) => e).sort((a, b) => a.seq - b.seq);
+        nextSeq = Math.max((await store.get("meta:seq")) ?? 1, (pending.at(-1)?.seq ?? 0) + 1);
+        if (pending.length)
+            void flush();
+    })());
+    const remember = async (d) => {
+        const { meta: _m, distanceMi: _d, ...clean } = d;
+        docs.set(d.path, clean);
+        await store.set(`d:${d.path}`, clean);
+    };
+    const forget = async (path) => {
+        docs.delete(path);
+        await store.delete(`d:${path}`);
+    };
+    /** A doc with pending writes applied (v < 0 marks a local version), or null. */
+    function effective(path) {
+        const base = docs.get(path) ?? null;
+        let cur = base ? { ...base, data: { ...base.data } } : null;
+        let local = false;
+        for (const e of pending) {
+            for (const w of e.writes) {
+                if (w.path !== path)
+                    continue;
+                local = true;
+                const data = applyWrite(cur?.data ?? null, w, e.at);
+                const id = path.split("/").pop();
+                cur = data ? { path, id, v: -e.seq, createTime: cur?.createTime ?? e.at, updateTime: e.at, data } : null;
+            }
+        }
+        return cur && local ? { ...cur, meta: { fromCache: true, hasPendingWrites: true } } : cur;
+    }
+    const pendingPaths = () => new Set(pending.flatMap((e) => e.writes.map((w) => w.path)));
+    const candidates = (q, base) => {
+        const paths = new Set(base ?? docs.keys());
+        for (const p of pendingPaths())
+            paths.add(p);
+        const out = [];
+        for (const p of paths) {
+            const d = effective(p);
+            if (d && inCollection(d, q))
+                out.push(d);
+        }
+        return out;
+    };
+    function emit(l) {
+        let snap;
+        if ("doc" in l.target) {
+            const d = effective(l.target.doc);
+            if (!d && !l.fromServer && !docs.has(l.target.doc) && network)
+                return; // nothing to show yet
+            snap = { reset: true, docs: d ? [d] : [], ...(d ? {} : { removed: [l.target.doc] }) };
+        }
+        else {
+            const q = l.target.query;
+            if (!l.fromServer && network && !candidates(q).length)
+                return;
+            const res = runLocal(candidates(q, l.server ? l.server.keys() : undefined), q);
+            snap = { reset: true, order: res.map((d) => d.path), docs: res };
+        }
+        const hasPendingWrites = snap.docs.some((d) => d.v < 0);
+        snap.meta = { fromCache: !l.fromServer, hasPendingWrites };
+        const sig = JSON.stringify([snap.docs.map((d) => [d.path, d.v]), snap.meta]);
+        if (sig === l.last)
+            return;
+        l.last = sig;
+        l.h.next(snap);
+    }
+    const touch = (paths) => {
+        for (const l of listeners) {
+            const hit = "doc" in l.target ? paths.includes(l.target.doc) : paths.some((p) => inCollection({ path: p }, l.target.query));
+            if (hit)
+                emit(l);
+        }
+    };
+    async function flush() {
+        // A flush already in flight may have checked the queue before this call's writes arrived (or
+        // before the network came back): wait for it, then go again if there's still work.
+        if (flushing) {
+            await flushing;
+            return pending.length && network && !retryTimer ? flush() : undefined;
+        }
+        flushing = (async () => {
+            while (pending.length && network) {
+                const e = pending[0];
+                const paths = e.writes.map((w) => w.path);
+                try {
+                    const r = await inner.commit({ writes: e.writes, opKey: e.opKey });
+                    // Refresh from the server: its values (timestamps, transforms) are the truth.
+                    const fresh = await inner.getAll(paths).catch(() => paths.map(() => null));
+                    pending.shift();
+                    await store.delete(`p:${pad(e.seq)}`);
+                    for (let i = 0; i < paths.length; i++)
+                        await (fresh[i] ? remember(fresh[i]) : forget(paths[i]));
+                    backoff = o.retryMs ?? 1000;
+                    waiters.get(e.seq)?.resolve(r);
+                    waiters.delete(e.seq);
+                    touch(paths);
+                }
+                catch (err) {
+                    if (isOffline(err)) {
+                        retryTimer ??= setTimeout(() => {
+                            retryTimer = null;
+                            void flush();
+                        }, backoff);
+                        backoff = Math.min(backoff * 2, 60_000);
+                        break;
+                    }
+                    // Refused by the server (rules, schema, preconditions): drop it, roll back locally.
+                    pending.shift();
+                    await store.delete(`p:${pad(e.seq)}`);
+                    waiters.get(e.seq)?.reject(err);
+                    waiters.delete(e.seq);
+                    touch(paths);
+                }
+            }
+        })().finally(() => {
+            flushing = null;
+        });
+        return flushing;
+    }
+    globalThis.addEventListener?.("online", () => void flush());
+    const t = {
+        get pendingWrites() {
+            return pending.length;
+        },
+        async getAll(paths) {
+            await init();
+            if (network) {
+                try {
+                    // Docs with pending writes are answered locally: our write is about to replace the server copy.
+                    const local = pendingPaths();
+                    const ask = paths.filter((p) => !local.has(p));
+                    const r = ask.length ? await inner.getAll(ask) : [];
+                    for (let i = 0; i < ask.length; i++)
+                        await (r[i] ? remember(r[i]) : forget(ask[i]));
+                    return paths.map((p) => effective(p));
+                }
+                catch (e) {
+                    if (!isOffline(e))
+                        throw e;
+                }
+            }
+            return paths.map((p) => {
+                if (!docs.has(p) && !pendingPaths().has(p))
+                    throw unavailable(`offline, and ${p} isn't cached`);
+                const d = effective(p);
+                return d ? { ...d, meta: { fromCache: true, hasPendingWrites: d.v < 0 } } : null;
+            });
+        },
+        async query(q) {
+            await init();
+            if (network) {
+                try {
+                    const r = await inner.query(q);
+                    for (const d of r.docs)
+                        await remember(d);
+                    // A complete, unlimited result is authoritative: cached docs it no longer includes are stale.
+                    if (q.limit === undefined && q.limitToLast === undefined && !q.offset && !r.hasMore && !q.startAfter && !q.startAt && !q.endAt && !q.endBefore && !q.near) {
+                        const got = new Set(r.docs.map((d) => d.path));
+                        for (const d of runLocal(docs.values(), q))
+                            if (!got.has(d.path))
+                                await forget(d.path);
+                    }
+                    return { docs: runLocal(candidates(q, r.docs.map((d) => d.path)), q), hasMore: r.hasMore };
+                }
+                catch (e) {
+                    if (!isOffline(e))
+                        throw e;
+                }
+            }
+            return { docs: runLocal(candidates(q), q).map((d) => ({ ...d, meta: { fromCache: true, hasPendingWrites: d.v < 0 } })), hasMore: false, fromCache: true };
+        },
+        // Counters need the network (they're buffered on the server, not in this cache).
+        ...(inner.counterInc ? { counterInc: inner.counterInc.bind(inner) } : {}),
+        ...(inner.refreshAuth ? { refreshAuth: inner.refreshAuth.bind(inner) } : {}),
+        async aggregate(q) {
+            await init();
+            if (network && !pending.length) {
+                try {
+                    return await inner.aggregate(q);
+                }
+                catch (e) {
+                    if (!isOffline(e))
+                        throw e;
+                }
+            }
+            const res = runLocal(candidates(q), { ...q, aggregate: undefined });
+            const out = {};
+            if (q.aggregate?.count)
+                out.count = res.length;
+            for (const f of q.aggregate?.sum ?? [])
+                out[`sum:${f}`] = res.reduce((s, d) => s + (typeof getPath(d.data, f) === "number" ? getPath(d.data, f) : 0), 0);
+            for (const f of q.aggregate?.avg ?? []) {
+                const xs = res.map((d) => getPath(d.data, f)).filter((x) => typeof x === "number");
+                out[`avg:${f}`] = xs.length ? xs.reduce((s, x) => s + x, 0) / xs.length : null;
+            }
+            return out;
+        },
+        async commit(req) {
+            await init();
+            // Several writes to one document apply in order (locally and on the server), as in Firestore.
+            const e = { seq: nextSeq++, opKey: req.opKey ?? `off:${crypto.randomUUID()}`, writes: req.writes, at: Date.now() };
+            pending.push(e);
+            await store.set(`p:${pad(e.seq)}`, e);
+            await store.set("meta:seq", nextSeq);
+            const done = new Promise((resolve, reject) => waiters.set(e.seq, { resolve, reject }));
+            settled.set(e.seq, done.then(() => undefined, () => undefined).finally(() => settled.delete(e.seq)));
+            touch(req.writes.map((w) => w.path));
+            void flush();
+            return done;
+        },
+        ...(inner.listen
+            ? {
+                listen(target, h) {
+                    // Live aggregates come from the server only (counting needs every document).
+                    if ("query" in target && target.query.aggregate)
+                        return inner.listen(target, h);
+                    const l = { target, h, server: null, fromServer: false, last: "" };
+                    listeners.add(l);
+                    void init().then(() => emit(l));
+                    const off = inner.listen(target, {
+                        next: (s) => {
+                            void (async () => {
+                                if (s.reset || !l.server)
+                                    l.server = new Map();
+                                for (const p of s.removed ?? []) {
+                                    l.server.delete(p);
+                                    if ("doc" in target)
+                                        await forget(p);
+                                }
+                                for (const d of s.docs) {
+                                    l.server.set(d.path, d);
+                                    await remember(d);
+                                }
+                                if (s.order)
+                                    for (const p of [...l.server.keys()])
+                                        if (!s.order.includes(p))
+                                            l.server.delete(p);
+                                l.fromServer = true;
+                                emit(l);
+                            })();
+                        },
+                        error: (err) => {
+                            listeners.delete(l);
+                            h.error(err);
+                        },
+                        // Resume from the server docs this listener holds.
+                        resume: () => (l.server ? Object.fromEntries([...l.server].map(([p, d]) => [p, d.v])) : undefined),
+                    });
+                    return () => {
+                        listeners.delete(l);
+                        off();
+                    };
+                },
+            }
+            : {}),
+        /** Resolves when the queue is empty, including writes restored from the store after a reload. */
+        async waitForPendingWrites() {
+            await init();
+            // Drive the queue (writes restored after a reload have no promise to wait on), then settle.
+            while (pending.length && network) {
+                await flush();
+                if (pending.length)
+                    await new Promise((r) => setTimeout(r, Math.min(backoff, 250)));
+            }
+            await Promise.all([...settled.values()]);
+        },
+        async disableNetwork() {
+            network = false;
+            for (const l of listeners) {
+                l.fromServer = false;
+                emit(l);
+            }
+        },
+        async enableNetwork() {
+            network = true;
+            await flush();
+        },
+        async clearPersistence() {
+            if (pending.length)
+                throw new EstraClientError("failed-precondition", "writes are still pending");
+            await store.clear();
+            docs.clear();
+        },
+    };
+    return t;
+}

package/dist/realtime.d.ts

@@ -0,0 +1,44 @@
+import type { DocOut, Query } from "./_schema/index.js";
+export type ListenTarget = {
+    doc: string;
+} | {
+    query: Query;
+};
+export interface Snap {
+    reset?: boolean;
+    order?: string[];
+    docs: DocOut[];
+    removed?: string[];
+    /** Live aggregate listeners: the new count/sum/avg values. */
+    aggregate?: Record<string, number | null>;
+    /** Offline cache: whether this result came from the server and includes local writes. */
+    meta?: {
+        fromCache: boolean;
+        hasPendingWrites: boolean;
+    };
+}
+export interface ListenHandlers {
+    next(s: Snap): void;
+    error(e: {
+        code: string;
+        message: string;
+    }): void;
+    /**
+     * Resume: the docs this listener already holds (path → version), sent when it (re)subscribes so
+     * the server answers with a delta instead of a reset. Undefined = nothing held.
+     */
+    resume?(): Record<string, number> | undefined;
+}
+export type Listen = (target: ListenTarget, h: ListenHandlers) => () => void;
+export interface RealtimeOptions {
+    url: string;
+    getToken?: () => Promise<string | null> | string | null;
+    WebSocket?: typeof WebSocket;
+    /** Re-send the token this often so long-lived connections outlive token expiry (default 4 min). */
+    tokenCheckMs?: number;
+}
+export declare function realtimeConnection(o: RealtimeOptions): {
+    listen: Listen;
+    close(): void;
+    refreshAuth(): void;
+};

package/dist/realtime.js

@@ -0,0 +1,112 @@
+export function realtimeConnection(o) {
+    const WS = o.WebSocket ?? globalThis.WebSocket;
+    const wsUrl = o.url.replace(/^http/, "ws").replace(/\/$/, "") + "/v1/listen";
+    const subs = new Map();
+    let ws = null;
+    let ready = false;
+    let lastToken;
+    let backoff = 500;
+    let seq = 0;
+    let timer = null;
+    let closed = false;
+    const send = (m) => {
+        if (ws && ready)
+            ws.send(JSON.stringify(m));
+    };
+    const subMsg = (id, s) => {
+        const have = s.h.resume?.();
+        return { t: "sub", id, ...s.target, ...(have ? { have } : {}) };
+    };
+    const sendAuth = async (force = false) => {
+        const t = o.getToken ? await o.getToken() : null;
+        if (!force && t === lastToken)
+            return;
+        lastToken = t;
+        ws?.send(JSON.stringify({ t: "auth", token: t }));
+    };
+    function open() {
+        if (ws || closed || !subs.size)
+            return;
+        if (!WS)
+            throw new Error("no WebSocket available: pass RealtimeOptions.WebSocket");
+        const sock = new WS(wsUrl);
+        ws = sock;
+        ready = false;
+        sock.addEventListener("open", () => {
+            backoff = 500;
+            void sendAuth(true);
+        });
+        sock.addEventListener("message", (e) => {
+            let m;
+            try {
+                m = JSON.parse(String(e.data));
+            }
+            catch {
+                return;
+            }
+            if (m.t === "ready") {
+                if (!ready) {
+                    ready = true;
+                    for (const [id, s] of subs)
+                        send(subMsg(id, s));
+                }
+            }
+            else if (m.t === "snap" && m.id)
+                subs.get(m.id)?.h.next(m);
+            else if (m.t === "error") {
+                if (m.id) {
+                    const s = subs.get(m.id);
+                    subs.delete(m.id);
+                    s?.h.error({ code: m.code ?? "internal", message: m.message ?? "listener failed" });
+                }
+                else if (m.code === "unauthenticated" && ready)
+                    void sendAuth(true);
+            }
+        });
+        sock.addEventListener("close", () => {
+            ws = null;
+            ready = false;
+            if (closed || !subs.size)
+                return;
+            setTimeout(open, backoff);
+            backoff = Math.min(backoff * 2, 30_000);
+        });
+        timer ??= setInterval(() => {
+            if (ready)
+                void sendAuth();
+        }, o.tokenCheckMs ?? 240_000);
+    }
+    return {
+        /** Send the current token now (call after sign-in / sign-out so open listeners switch user). */
+        refreshAuth() {
+            if (ready)
+                void sendAuth();
+        },
+        listen(target, h) {
+            const id = `l${++seq}`;
+            subs.set(id, { target, h });
+            if (ws && ready)
+                send(subMsg(id, { target, h }));
+            else
+                open();
+            return () => {
+                if (!subs.delete(id))
+                    return;
+                send({ t: "unsub", id });
+                if (!subs.size) {
+                    ws?.close(1000, "no listeners");
+                    if (timer)
+                        clearInterval(timer);
+                    timer = null;
+                }
+            };
+        },
+        close() {
+            closed = true;
+            subs.clear();
+            if (timer)
+                clearInterval(timer);
+            ws?.close(1000, "closed");
+        },
+    };
+}

package/dist/storage.d.ts

@@ -0,0 +1,57 @@
+export interface StorageOptions {
+    url: string;
+    getToken?: () => Promise<string | null> | string | null;
+    fetch?: typeof fetch;
+}
+export interface FullMetadata {
+    name: string;
+    fullPath: string;
+    bucket: string;
+    size: number;
+    contentType: string;
+    customMetadata: Record<string, string>;
+    timeCreated: string;
+    updated: string;
+    md5Hash: string | null;
+    downloadTokens?: string;
+}
+export declare class FirebaseStorageLike {
+    readonly base: string;
+    readonly o: StorageOptions;
+    constructor(o: StorageOptions);
+}
+export declare const getStorage: (o: StorageOptions) => FirebaseStorageLike;
+export declare class StorageReference {
+    readonly storage: FirebaseStorageLike;
+    readonly fullPath: string;
+    constructor(storage: FirebaseStorageLike, fullPath: string);
+    get name(): string;
+    get parent(): StorageReference | null;
+    get root(): StorageReference;
+    toString(): string;
+}
+export declare const ref: (s: FirebaseStorageLike | StorageReference, path?: string) => StorageReference;
+export declare const child: (r: StorageReference, path: string) => StorageReference;
+export interface UploadMetadata {
+    contentType?: string;
+    customMetadata?: Record<string, string>;
+}
+export declare function uploadBytes(r: StorageReference, data: Blob | ArrayBuffer | Uint8Array, m?: UploadMetadata): Promise<{
+    ref: StorageReference;
+    metadata: FullMetadata;
+}>;
+export declare function getMetadata(r: StorageReference): Promise<FullMetadata>;
+/** A long-lived URL (download token, like Firebase): works in <img src> without credentials. */
+export declare function getDownloadURL(r: StorageReference): Promise<string>;
+export declare function getBytes(r: StorageReference): Promise<ArrayBuffer>;
+export declare function deleteObject(r: StorageReference): Promise<void>;
+export interface ListResult {
+    items: StorageReference[];
+    prefixes: StorageReference[];
+    nextPageToken?: string;
+}
+export declare function list(r: StorageReference, o?: {
+    maxResults?: number;
+    pageToken?: string;
+}): Promise<ListResult>;
+export declare function listAll(r: StorageReference): Promise<ListResult>;

package/dist/storage.js

@@ -0,0 +1,111 @@
+// Firebase Storage's modular API on Estra's storage plugin:
+//   const storage = getStorage({ url, getToken: () => auth.getIdToken() });
+//   await uploadBytes(ref(storage, "profile/u1/a.jpg"), file, { contentType: "image/jpeg" });
+//   const src = await getDownloadURL(ref(storage, "profile/u1/a.jpg"));
+import { EstraClientError } from "./transport.js";
+export class FirebaseStorageLike {
+    base;
+    o;
+    constructor(o) {
+        this.o = o;
+        this.base = o.url.replace(/\/$/, "");
+    }
+}
+export const getStorage = (o) => new FirebaseStorageLike(o);
+export class StorageReference {
+    storage;
+    fullPath;
+    constructor(storage, fullPath) {
+        this.storage = storage;
+        this.fullPath = fullPath.replace(/^\/+|\/+$/g, "");
+    }
+    get name() {
+        return this.fullPath.split("/").pop() ?? "";
+    }
+    get parent() {
+        return this.fullPath ? new StorageReference(this.storage, this.fullPath.split("/").slice(0, -1).join("/")) : null;
+    }
+    get root() {
+        return new StorageReference(this.storage, "");
+    }
+    toString() {
+        return `estra://${this.fullPath}`;
+    }
+}
+export const ref = (s, path = "") => s instanceof StorageReference ? new StorageReference(s.storage, [s.fullPath, path].filter(Boolean).join("/")) : new StorageReference(s, path);
+export const child = (r, path) => ref(r, path);
+const enc = (p) => encodeURIComponent(p);
+async function call(s, path, init = {}) {
+    const headers = new Headers(init.headers);
+    const t = s.o.getToken ? await s.o.getToken() : null;
+    if (t)
+        headers.set("authorization", `Bearer ${t}`);
+    let r;
+    try {
+        r = await (s.o.fetch ?? fetch)(`${s.base}${path}`, { ...init, headers });
+    }
+    catch {
+        throw new EstraClientError("unavailable", "network request failed");
+    }
+    if (!r.ok) {
+        const j = (await r.json().catch(() => ({})));
+        throw new EstraClientError(j.error?.code ?? "unavailable", j.error?.message ?? `HTTP ${r.status}`);
+    }
+    return r;
+}
+const toMeta = (m) => ({
+    name: m.name.split("/").pop() ?? m.name,
+    fullPath: m.name,
+    bucket: m.bucket,
+    size: m.size,
+    contentType: m.contentType,
+    customMetadata: m.metadata,
+    timeCreated: new Date(m.timeCreated).toISOString(),
+    updated: new Date(m.updated).toISOString(),
+    md5Hash: m.md5Hash,
+    ...(m.downloadTokens ? { downloadTokens: m.downloadTokens } : {}),
+});
+export async function uploadBytes(r, data, m = {}) {
+    const contentType = m.contentType ?? (typeof Blob !== "undefined" && data instanceof Blob && data.type ? data.type : "application/octet-stream");
+    const headers = { "content-type": contentType };
+    if (m.customMetadata)
+        headers["x-estra-metadata"] = JSON.stringify(m.customMetadata);
+    const res = await call(r.storage, `/v1/storage/o/${enc(r.fullPath)}`, { method: "PUT", headers, body: data });
+    return { ref: r, metadata: toMeta(await res.json()) };
+}
+export async function getMetadata(r) {
+    return toMeta(await (await call(r.storage, `/v1/storage/meta/${enc(r.fullPath)}`)).json());
+}
+/** A long-lived URL (download token, like Firebase): works in <img src> without credentials. */
+export async function getDownloadURL(r) {
+    const m = await getMetadata(r);
+    if (!m.downloadTokens)
+        throw new EstraClientError("not-found", "this object has no download token");
+    return `${r.storage.base}/v1/storage/o/${enc(r.fullPath)}?token=${m.downloadTokens}`;
+}
+export async function getBytes(r) {
+    return (await call(r.storage, `/v1/storage/o/${enc(r.fullPath)}`)).arrayBuffer();
+}
+export async function deleteObject(r) {
+    await call(r.storage, `/v1/storage/o/${enc(r.fullPath)}`, { method: "DELETE" });
+}
+export async function list(r, o = {}) {
+    const res = await call(r.storage, "/v1/storage/list", {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ prefix: r.fullPath, ...(o.maxResults ? { limit: o.maxResults } : {}), ...(o.pageToken ? { cursor: o.pageToken } : {}) }),
+    });
+    const j = (await res.json());
+    return { items: j.items.map((i) => new StorageReference(r.storage, i.name)), prefixes: j.prefixes.map((p) => new StorageReference(r.storage, p)), ...(j.cursor ? { nextPageToken: j.cursor } : {}) };
+}
+export async function listAll(r) {
+    const out = { items: [], prefixes: [] };
+    let pageToken;
+    do {
+        const page = await list(r, { maxResults: 1000, ...(pageToken ? { pageToken } : {}) });
+        out.items.push(...page.items);
+        out.prefixes.push(...page.prefixes);
+        pageToken = page.nextPageToken;
+    } while (pageToken);
+    return out;
+}

package/dist/store.d.ts

@@ -0,0 +1,37 @@
+export interface CacheStore {
+    get<T>(key: string): Promise<T | undefined>;
+    set(key: string, value: unknown): Promise<void>;
+    delete(key: string): Promise<void>;
+    /** Entries whose key starts with `prefix`. */
+    list<T>(prefix: string): Promise<[string, T][]>;
+    clear(): Promise<void>;
+}
+export declare function memoryStore(): CacheStore;
+interface Req<T> {
+    result: T;
+    error: unknown;
+    onsuccess: (() => void) | null;
+    onerror: (() => void) | null;
+}
+interface Store {
+    get(k: string): Req<any>;
+    put(v: unknown, k: string): Req<unknown>;
+    delete(k: string): Req<unknown>;
+    clear(): Req<unknown>;
+    getAllKeys(range: unknown): Req<unknown[]>;
+    getAll(range: unknown): Req<unknown[]>;
+}
+interface Db {
+    transaction(name: string, mode: "readonly" | "readwrite"): {
+        objectStore(name: string): Store;
+    };
+    createObjectStore(name: string): unknown;
+}
+interface Factory {
+    open(name: string, version: number): Req<Db> & {
+        onupgradeneeded: (() => void) | null;
+    };
+}
+/** One IndexedDB database with one object store; values are structured-cloned. */
+export declare function indexedDbStore(name: string, idb?: Factory | undefined): CacheStore;
+export {};