@zenfs/dom 0.0.1

package/dist/backends/FileSystemAccess.d.ts

@@ -0,0 +1,45 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Cred } from '@zenfs/core/cred.js';
+import { File, FileFlag, PreloadFile } from '@zenfs/core/file.js';
+import { BaseFileSystem, FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { Stats } from '@zenfs/core/stats.js';
+import { type BackendOptions } from '@zenfs/core/backends/backend.js';
+declare global {
+    interface FileSystemDirectoryHandle {
+        [Symbol.iterator](): IterableIterator<[string, FileSystemHandle]>;
+        entries(): IterableIterator<[string, FileSystemHandle]>;
+        keys(): IterableIterator<string>;
+        values(): IterableIterator<FileSystemHandle>;
+    }
+}
+interface FileSystemAccessFileSystemOptions {
+    handle: FileSystemDirectoryHandle;
+}
+export declare class FileSystemAccessFile extends PreloadFile<FileSystemAccessFileSystem> implements File {
+    constructor(_fs: FileSystemAccessFileSystem, _path: string, _flag: FileFlag, _stat: Stats, contents?: Buffer);
+    sync(): Promise<void>;
+    close(): Promise<void>;
+}
+export declare class FileSystemAccessFileSystem extends BaseFileSystem {
+    static readonly Name = "FileSystemAccess";
+    static Create: any;
+    static readonly Options: BackendOptions;
+    static isAvailable(): boolean;
+    private _handles;
+    constructor({ handle }: FileSystemAccessFileSystemOptions);
+    get metadata(): FileSystemMetadata;
+    _sync(p: string, data: Buffer, stats: Stats, cred: Cred): Promise<void>;
+    rename(oldPath: string, newPath: string, cred: Cred): Promise<void>;
+    writeFile(fname: string, data: any, encoding: string | null, flag: FileFlag, mode: number, cred: Cred, createFile?: boolean): Promise<void>;
+    createFile(p: string, flag: FileFlag, mode: number, cred: Cred): Promise<File>;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    exists(p: string, cred: Cred): Promise<boolean>;
+    openFile(path: string, flags: FileFlag, cred: Cred): Promise<File>;
+    unlink(path: string, cred: Cred): Promise<void>;
+    rmdir(path: string, cred: Cred): Promise<void>;
+    mkdir(p: string, mode: any, cred: Cred): Promise<void>;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    private newFile;
+    private getHandle;
+}
+export {};

package/dist/backends/FileSystemAccess.js

@@ -0,0 +1,263 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var _a;
+import { basename, dirname, join } from 'path';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { Cred } from '@zenfs/core/cred.js';
+import { FileFlag, PreloadFile } from '@zenfs/core/file.js';
+import { BaseFileSystem } from '@zenfs/core/filesystem.js';
+import { Stats, FileType } from '@zenfs/core/stats.js';
+import { CreateBackend } from '@zenfs/core/backends/backend.js';
+import { Buffer } from 'buffer';
+const handleError = (path = '', error) => {
+    if (error.name === 'NotFoundError') {
+        throw ApiError.ENOENT(path);
+    }
+    throw error;
+};
+export class FileSystemAccessFile extends PreloadFile {
+    constructor(_fs, _path, _flag, _stat, contents) {
+        super(_fs, _path, _flag, _stat, contents);
+    }
+    sync() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isDirty()) {
+                yield this._fs._sync(this.getPath(), this.getBuffer(), this.getStats(), Cred.Root);
+                this.resetDirty();
+            }
+        });
+    }
+    close() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.sync();
+        });
+    }
+}
+export class FileSystemAccessFileSystem extends BaseFileSystem {
+    static isAvailable() {
+        return typeof FileSystemHandle === 'function';
+    }
+    constructor({ handle }) {
+        super();
+        this._handles = new Map();
+        this._handles.set('/', handle);
+    }
+    get metadata() {
+        return Object.assign(Object.assign({}, super.metadata), { name: _a.Name });
+    }
+    _sync(p, data, stats, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const currentStats = yield this.stat(p, cred);
+            if (stats.mtime !== currentStats.mtime) {
+                yield this.writeFile(p, data, null, FileFlag.getFileFlag('w'), currentStats.mode, cred);
+            }
+        });
+    }
+    rename(oldPath, newPath, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const handle = yield this.getHandle(oldPath);
+                if (handle instanceof FileSystemDirectoryHandle) {
+                    const files = yield this.readdir(oldPath, cred);
+                    yield this.mkdir(newPath, 'wx', cred);
+                    if (files.length === 0) {
+                        yield this.unlink(oldPath, cred);
+                    }
+                    else {
+                        for (const file of files) {
+                            yield this.rename(join(oldPath, file), join(newPath, file), cred);
+                            yield this.unlink(oldPath, cred);
+                        }
+                    }
+                }
+                if (handle instanceof FileSystemFileHandle) {
+                    const oldFile = yield handle.getFile(), destFolder = yield this.getHandle(dirname(newPath));
+                    if (destFolder instanceof FileSystemDirectoryHandle) {
+                        const newFile = yield destFolder.getFileHandle(basename(newPath), { create: true });
+                        const writable = yield newFile.createWritable();
+                        const buffer = yield oldFile.arrayBuffer();
+                        yield writable.write(buffer);
+                        writable.close();
+                        yield this.unlink(oldPath, cred);
+                    }
+                }
+            }
+            catch (err) {
+                handleError(oldPath, err);
+            }
+        });
+    }
+    writeFile(fname, data, encoding, flag, mode, cred, createFile) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const handle = yield this.getHandle(dirname(fname));
+            if (handle instanceof FileSystemDirectoryHandle) {
+                const file = yield handle.getFileHandle(basename(fname), { create: true });
+                const writable = yield file.createWritable();
+                yield writable.write(data);
+                yield writable.close();
+                //return createFile ? this.newFile(fname, flag, data) : undefined;
+            }
+        });
+    }
+    createFile(p, flag, mode, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.writeFile(p, Buffer.alloc(0), null, flag, mode, cred, true);
+            return this.openFile(p, flag, cred);
+        });
+    }
+    stat(path, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const handle = yield this.getHandle(path);
+            if (!handle) {
+                throw ApiError.FileError(ErrorCode.EINVAL, path);
+            }
+            if (handle instanceof FileSystemDirectoryHandle) {
+                return new Stats(FileType.DIRECTORY, 4096);
+            }
+            if (handle instanceof FileSystemFileHandle) {
+                const { lastModified, size } = yield handle.getFile();
+                return new Stats(FileType.FILE, size, undefined, undefined, lastModified);
+            }
+        });
+    }
+    exists(p, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.getHandle(p);
+                return true;
+            }
+            catch (e) {
+                return false;
+            }
+        });
+    }
+    openFile(path, flags, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const handle = yield this.getHandle(path);
+            if (handle instanceof FileSystemFileHandle) {
+                const file = yield handle.getFile();
+                const buffer = yield file.arrayBuffer();
+                return this.newFile(path, flags, buffer, file.size, file.lastModified);
+            }
+        });
+    }
+    unlink(path, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const handle = yield this.getHandle(dirname(path));
+            if (handle instanceof FileSystemDirectoryHandle) {
+                try {
+                    yield handle.removeEntry(basename(path), { recursive: true });
+                }
+                catch (e) {
+                    handleError(path, e);
+                }
+            }
+        });
+    }
+    rmdir(path, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.unlink(path, cred);
+        });
+    }
+    mkdir(p, mode, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const overwrite = mode && mode.flag && mode.flag.includes('w') && !mode.flag.includes('x');
+            const existingHandle = yield this.getHandle(p);
+            if (existingHandle && !overwrite) {
+                throw ApiError.EEXIST(p);
+            }
+            const handle = yield this.getHandle(dirname(p));
+            if (handle instanceof FileSystemDirectoryHandle) {
+                yield handle.getDirectoryHandle(basename(p), { create: true });
+            }
+        });
+    }
+    readdir(path, cred) {
+        var _b, e_1, _c, _d;
+        return __awaiter(this, void 0, void 0, function* () {
+            const handle = yield this.getHandle(path);
+            if (!(handle instanceof FileSystemDirectoryHandle)) {
+                throw ApiError.ENOTDIR(path);
+            }
+            const _keys = [];
+            try {
+                for (var _e = true, _f = __asyncValues(handle.keys()), _g; _g = yield _f.next(), _b = _g.done, !_b; _e = true) {
+                    _d = _g.value;
+                    _e = false;
+                    const key = _d;
+                    _keys.push(join(path, key));
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_e && !_b && (_c = _f.return)) yield _c.call(_f);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return _keys;
+        });
+    }
+    newFile(path, flag, data, size, lastModified) {
+        return new FileSystemAccessFile(this, path, flag, new Stats(FileType.FILE, size || 0, undefined, undefined, lastModified || new Date().getTime()), Buffer.from(data));
+    }
+    getHandle(path) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._handles.has(path)) {
+                return this._handles.get(path);
+            }
+            let walkedPath = '/';
+            const [, ...pathParts] = path.split('/');
+            const getHandleParts = ([pathPart, ...remainingPathParts]) => __awaiter(this, void 0, void 0, function* () {
+                const walkingPath = join(walkedPath, pathPart);
+                const continueWalk = (handle) => {
+                    walkedPath = walkingPath;
+                    this._handles.set(walkedPath, handle);
+                    if (remainingPathParts.length === 0) {
+                        return this._handles.get(path);
+                    }
+                    getHandleParts(remainingPathParts);
+                };
+                const handle = this._handles.get(walkedPath);
+                try {
+                    return yield continueWalk(yield handle.getDirectoryHandle(pathPart));
+                }
+                catch (error) {
+                    if (error.name === 'TypeMismatchError') {
+                        try {
+                            return yield continueWalk(yield handle.getFileHandle(pathPart));
+                        }
+                        catch (err) {
+                            handleError(walkingPath, err);
+                        }
+                    }
+                    else if (error.message === 'Name is not allowed.') {
+                        throw new ApiError(ErrorCode.ENOENT, error.message, walkingPath);
+                    }
+                    else {
+                        handleError(walkingPath, error);
+                    }
+                }
+            });
+            yield getHandleParts(pathParts);
+        });
+    }
+}
+_a = FileSystemAccessFileSystem;
+FileSystemAccessFileSystem.Name = 'FileSystemAccess';
+FileSystemAccessFileSystem.Create = CreateBackend.bind(_a);
+FileSystemAccessFileSystem.Options = {};

package/dist/backends/HTTPRequest.d.ts

@@ -0,0 +1,88 @@
+/// <reference types="node" resolution-mode="require"/>
+import { BaseFileSystem, FileContents, FileSystemMetadata } from '@zenfs/core/filesystem.js';
+import { File, FileFlag } from '@zenfs/core/file.js';
+import { Stats } from '@zenfs/core/stats.js';
+import { Cred } from '@zenfs/core/cred.js';
+import { type BackendOptions } from '@zenfs/core/backends/backend.js';
+export interface HTTPRequestIndex {
+    [key: string]: string;
+}
+export declare namespace HTTPRequest {
+    /**
+     * Configuration options for a HTTPRequest file system.
+     */
+    interface Options {
+        /**
+         * URL to a file index as a JSON file or the file index object itself, generated with the make_http_index script.
+         * Defaults to `index.json`.
+         */
+        index?: string | HTTPRequestIndex;
+        /** Used as the URL prefix for fetched files.
+         * Default: Fetch files relative to the index.
+         */
+        baseUrl?: string;
+    }
+}
+/**
+ * A simple filesystem backed by HTTP downloads. You must create a directory listing using the
+ * `make_http_index` tool provided by ZenFS.
+ *
+ * If you install ZenFS globally with `npm i -g zenfs`, you can generate a listing by
+ * running `make_http_index` in your terminal in the directory you would like to index:
+ *
+ * ```
+ * make_http_index > index.json
+ * ```
+ *
+ * Listings objects look like the following:
+ *
+ * ```json
+ * {
+ *   "home": {
+ *     "jvilk": {
+ *       "someFile.txt": null,
+ *       "someDir": {
+ *         // Empty directory
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * *This example has the folder `/home/jvilk` with subfile `someFile.txt` and subfolder `someDir`.*
+ */
+export declare class HTTPRequest extends BaseFileSystem {
+    static readonly Name = "HTTPRequest";
+    static Create: any;
+    static readonly Options: BackendOptions;
+    static isAvailable(): boolean;
+    readonly prefixUrl: string;
+    private _index;
+    private _requestFileInternal;
+    private _requestFileSizeInternal;
+    constructor({ index, baseUrl }: HTTPRequest.Options);
+    get metadata(): FileSystemMetadata;
+    empty(): void;
+    /**
+     * Special HTTPFS function: Preload the given file into the index.
+     * @param [String] path
+     * @param [ZenFS.Buffer] buffer
+     */
+    preloadFile(path: string, buffer: Buffer): void;
+    stat(path: string, cred: Cred): Promise<Stats>;
+    open(path: string, flags: FileFlag, mode: number, cred: Cred): Promise<File>;
+    readdir(path: string, cred: Cred): Promise<string[]>;
+    /**
+     * We have the entire file as a buffer; optimize readFile.
+     */
+    readFile(fname: string, encoding: BufferEncoding, flag: FileFlag, cred: Cred): Promise<FileContents>;
+    private _getHTTPPath;
+    /**
+     * Asynchronously download the given file.
+     */
+    private _requestFile;
+    /**
+     * Only requests the HEAD content, for the file size.
+     */
+    private _requestFileSize;
+}

package/dist/backends/HTTPRequest.js

@@ -0,0 +1,223 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var _a;
+import { BaseFileSystem } from '@zenfs/core/filesystem.js';
+import { ApiError, ErrorCode } from '@zenfs/core/ApiError.js';
+import { copyingSlice } from '@zenfs/core/utils.js';
+import { ActionType, NoSyncFile } from '@zenfs/core/file.js';
+import { Stats } from '@zenfs/core/stats.js';
+import { fetchIsAvailable, fetchFile, fetchFileSize } from '../fetch.js';
+import { FileIndex, isFileInode, isDirInode } from '../file_index.js';
+import { CreateBackend } from '@zenfs/core/backends/backend.js';
+import { R_OK } from '@zenfs/core/emulation/constants.js';
+/**
+ * A simple filesystem backed by HTTP downloads. You must create a directory listing using the
+ * `make_http_index` tool provided by ZenFS.
+ *
+ * If you install ZenFS globally with `npm i -g zenfs`, you can generate a listing by
+ * running `make_http_index` in your terminal in the directory you would like to index:
+ *
+ * ```
+ * make_http_index > index.json
+ * ```
+ *
+ * Listings objects look like the following:
+ *
+ * ```json
+ * {
+ *   "home": {
+ *     "jvilk": {
+ *       "someFile.txt": null,
+ *       "someDir": {
+ *         // Empty directory
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * *This example has the folder `/home/jvilk` with subfile `someFile.txt` and subfolder `someDir`.*
+ */
+export class HTTPRequest extends BaseFileSystem {
+    static isAvailable() {
+        return fetchIsAvailable;
+    }
+    constructor({ index, baseUrl = '' }) {
+        super();
+        if (!index) {
+            index = 'index.json';
+        }
+        const indexRequest = typeof index == 'string' ? fetchFile(index, 'json') : Promise.resolve(index);
+        this._ready = indexRequest.then(data => {
+            this._index = FileIndex.fromListing(data);
+            return this;
+        });
+        // prefix_url must end in a directory separator.
+        if (baseUrl.length > 0 && baseUrl.charAt(baseUrl.length - 1) !== '/') {
+            baseUrl = baseUrl + '/';
+        }
+        this.prefixUrl = baseUrl;
+        this._requestFileInternal = fetchFile;
+        this._requestFileSizeInternal = fetchFileSize;
+    }
+    get metadata() {
+        return Object.assign(Object.assign({}, super.metadata), { name: _a.Name, readonly: true });
+    }
+    empty() {
+        this._index.fileIterator(function (file) {
+            file.fileData = null;
+        });
+    }
+    /**
+     * Special HTTPFS function: Preload the given file into the index.
+     * @param [String] path
+     * @param [ZenFS.Buffer] buffer
+     */
+    preloadFile(path, buffer) {
+        const inode = this._index.getInode(path);
+        if (isFileInode(inode)) {
+            if (inode === null) {
+                throw ApiError.ENOENT(path);
+            }
+            const stats = inode.getData();
+            stats.size = buffer.length;
+            stats.fileData = buffer;
+        }
+        else {
+            throw ApiError.EISDIR(path);
+        }
+    }
+    stat(path, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const inode = this._index.getInode(path);
+            if (inode === null) {
+                throw ApiError.ENOENT(path);
+            }
+            if (!inode.toStats().hasAccess(R_OK, cred)) {
+                throw ApiError.EACCES(path);
+            }
+            let stats;
+            if (isFileInode(inode)) {
+                stats = inode.getData();
+                // At this point, a non-opened file will still have default stats from the listing.
+                if (stats.size < 0) {
+                    stats.size = yield this._requestFileSize(path);
+                }
+            }
+            else if (isDirInode(inode)) {
+                stats = inode.getStats();
+            }
+            else {
+                throw ApiError.FileError(ErrorCode.EINVAL, path);
+            }
+            return stats;
+        });
+    }
+    open(path, flags, mode, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // INVARIANT: You can't write to files on this file system.
+            if (flags.isWriteable()) {
+                throw new ApiError(ErrorCode.EPERM, path);
+            }
+            // Check if the path exists, and is a file.
+            const inode = this._index.getInode(path);
+            if (inode === null) {
+                throw ApiError.ENOENT(path);
+            }
+            if (!inode.toStats().hasAccess(flags.getMode(), cred)) {
+                throw ApiError.EACCES(path);
+            }
+            if (isFileInode(inode) || isDirInode(inode)) {
+                switch (flags.pathExistsAction()) {
+                    case ActionType.THROW_EXCEPTION:
+                    case ActionType.TRUNCATE_FILE:
+                        throw ApiError.EEXIST(path);
+                    case ActionType.NOP:
+                        if (isDirInode(inode)) {
+                            const stats = inode.getStats();
+                            return new NoSyncFile(this, path, flags, stats, stats.fileData || undefined);
+                        }
+                        const stats = inode.getData();
+                        // Use existing file contents.
+                        // XXX: Uh, this maintains the previously-used flag.
+                        if (stats.fileData) {
+                            return new NoSyncFile(this, path, flags, Stats.clone(stats), stats.fileData);
+                        }
+                        // @todo be lazier about actually requesting the file
+                        const buffer = yield this._requestFile(path, 'buffer');
+                        // we don't initially have file sizes
+                        stats.size = buffer.length;
+                        stats.fileData = buffer;
+                        return new NoSyncFile(this, path, flags, Stats.clone(stats), buffer);
+                    default:
+                        throw new ApiError(ErrorCode.EINVAL, 'Invalid FileMode object.');
+                }
+            }
+            else {
+                throw ApiError.EPERM(path);
+            }
+        });
+    }
+    readdir(path, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.readdirSync(path, cred);
+        });
+    }
+    /**
+     * We have the entire file as a buffer; optimize readFile.
+     */
+    readFile(fname, encoding, flag, cred) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Get file.
+            const fd = yield this.open(fname, flag, 0o644, cred);
+            try {
+                const fdCast = fd;
+                const fdBuff = fdCast.getBuffer();
+                if (encoding === null) {
+                    return copyingSlice(fdBuff);
+                }
+                return fdBuff.toString(encoding);
+            }
+            finally {
+                yield fd.close();
+            }
+        });
+    }
+    _getHTTPPath(filePath) {
+        if (filePath.charAt(0) === '/') {
+            filePath = filePath.slice(1);
+        }
+        return this.prefixUrl + filePath;
+    }
+    _requestFile(p, type) {
+        return this._requestFileInternal(this._getHTTPPath(p), type);
+    }
+    /**
+     * Only requests the HEAD content, for the file size.
+     */
+    _requestFileSize(path) {
+        return this._requestFileSizeInternal(this._getHTTPPath(path));
+    }
+}
+_a = HTTPRequest;
+HTTPRequest.Name = 'HTTPRequest';
+HTTPRequest.Create = CreateBackend.bind(_a);
+HTTPRequest.Options = {
+    index: {
+        type: ['string', 'object'],
+        optional: true,
+        description: 'URL to a file index as a JSON file or the file index object itself, generated with the make_http_index script. Defaults to `index.json`.',
+    },
+    baseUrl: {
+        type: 'string',
+        optional: true,
+        description: 'Used as the URL prefix for fetched files. Default: Fetch files relative to the index.',
+    },
+};

package/dist/backends/IndexedDB.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" resolution-mode="require"/>
+import { AsyncKeyValueROTransaction, AsyncKeyValueRWTransaction, AsyncKeyValueStore, AsyncKeyValueFileSystem } from '@zenfs/core/backends/AsyncStore.js';
+import { type BackendOptions } from '@zenfs/core/backends/backend.js';
+/**
+ * @hidden
+ */
+export declare class IndexedDBROTransaction implements AsyncKeyValueROTransaction {
+    tx: IDBTransaction;
+    store: IDBObjectStore;
+    constructor(tx: IDBTransaction, store: IDBObjectStore);
+    get(key: string): Promise<Buffer>;
+}
+/**
+ * @hidden
+ */
+export declare class IndexedDBRWTransaction extends IndexedDBROTransaction implements AsyncKeyValueRWTransaction, AsyncKeyValueROTransaction {
+    constructor(tx: IDBTransaction, store: IDBObjectStore);
+    /**
+     * @todo return false when add has a key conflict (no error)
+     */
+    put(key: string, data: Buffer, overwrite: boolean): Promise<boolean>;
+    del(key: string): Promise<void>;
+    commit(): Promise<void>;
+    abort(): Promise<void>;
+}
+export declare class IndexedDBStore implements AsyncKeyValueStore {
+    private db;
+    private storeName;
+    static Create(storeName: string, indexedDB: IDBFactory): Promise<IndexedDBStore>;
+    constructor(db: IDBDatabase, storeName: string);
+    name(): string;
+    clear(): Promise<void>;
+    beginTransaction(type: 'readonly'): AsyncKeyValueROTransaction;
+    beginTransaction(type: 'readwrite'): AsyncKeyValueRWTransaction;
+}
+export declare namespace IndexedDBFileSystem {
+    /**
+     * Configuration options for the IndexedDB file system.
+     */
+    interface Options {
+        /**
+         * The name of this file system. You can have multiple IndexedDB file systems operating at once, but each must have a different name.
+         */
+        storeName?: string;
+        /**
+         * The size of the inode cache. Defaults to 100. A size of 0 or below disables caching.
+         */
+        cacheSize?: number;
+        /**
+         * The IDBFactory to use. Defaults to `globalThis.indexedDB`.
+         */
+        idbFactory?: IDBFactory;
+    }
+}
+/**
+ * A file system that uses the IndexedDB key value file system.
+ */
+export declare class IndexedDBFileSystem extends AsyncKeyValueFileSystem {
+    static readonly Name = "IndexedDB";
+    static Create: any;
+    static readonly Options: BackendOptions;
+    static isAvailable(idbFactory?: IDBFactory): boolean;
+    constructor({ cacheSize, storeName, idbFactory }: IndexedDBFileSystem.Options);
+}