@zenfs/core 0.0.12 → 0.1.0

package/dist/emulation/sync.js

@@ -1,7 +1,10 @@
 import { ApiError, ErrorCode } from '../ApiError.js';
 import { FileFlag } from '../file.js';
-import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts } from './shared.js';
+import { BigIntStats } from '../stats.js';
+import { normalizePath, cred, getFdForFile, normalizeMode, normalizeOptions, fdMap, fd2file, normalizeTime, resolveFS, fixError, mounts, } from './shared.js';
 import { decode, encode } from '../utils.js';
+import { Dirent } from './dir.js';
+import { join } from './path.js';
 function doOp(...[name, resolveSymlinks, path, ...args]) {
     path = normalizePath(path);
     const { fs, path: resolvedPath } = resolveFS(resolveSymlinks && existsSync(path) ? realpathSync(path) : path);
@@ -36,6 +39,7 @@ export function renameSync(oldPath, newPath) {
         throw fixError(e, paths);
     }
 }
+renameSync;
 /**
  * Test whether or not the given path exists by checking with the file system.
  * @param path
@@ -53,24 +57,17 @@ export function existsSync(path) {
         throw e;
     }
 }
-/**
- * Synchronous `stat`.
- * @param path
- * @returns Stats
- */
-export function statSync(path) {
-    return doOp('statSync', true, path, cred);
+existsSync;
+export function statSync(path, options) {
+    const stats = doOp('statSync', true, path, cred);
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
-/**
- * Synchronous `lstat`.
- * `lstat()` is identical to `stat()`, except that if path is a symbolic link,
- * then the link itself is stat-ed, not the file that it refers to.
- * @param path
- * @return [ZenFS.node.fs.Stats]
- */
-export function lstatSync(path) {
-    return doOp('statSync', false, path, cred);
+statSync;
+export function lstatSync(path, options) {
+    const stats = doOp('statSync', false, path, cred);
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
+lstatSync;
 /**
  * Synchronous `truncate`.
  * @param path
@@ -82,6 +79,7 @@ export function truncateSync(path, len = 0) {
     }
     return doOp('truncateSync', true, path, len, cred);
 }
+truncateSync;
 /**
  * Synchronous `unlink`.
  * @param path
@@ -89,18 +87,20 @@ export function truncateSync(path, len = 0) {
 export function unlinkSync(path) {
     return doOp('unlinkSync', false, path, cred);
 }
+unlinkSync;
 /**
  * Synchronous file open.
  * @see http://www.manpagez.com/man/2/open/
  * @param path
  * @param flags
  * @param mode defaults to `0644`
- * @return [ZenFS.File]
+ * @returns file descriptor
  */
 export function openSync(path, flag, mode = 0o644) {
     const file = doOp('openSync', true, path, FileFlag.getFileFlag(flag), normalizeMode(mode, 0o644), cred);
     return getFdForFile(file);
 }
+openSync;
 export function readFileSync(filename, arg2 = {}) {
     const options = normalizeOptions(arg2, null, 'r', null);
     const flag = FileFlag.getFileFlag(options.flag);
@@ -116,6 +116,7 @@ export function readFileSync(filename, arg2 = {}) {
             return data;
     }
 }
+readFileSync;
 export function writeFileSync(filename, data, arg3) {
     const options = normalizeOptions(arg3, 'utf8', 'w', 0o644);
     const flag = FileFlag.getFileFlag(options.flag);
@@ -128,6 +129,7 @@ export function writeFileSync(filename, data, arg3) {
     const encodedData = typeof data == 'string' ? encode(data) : data;
     return doOp('writeFileSync', true, filename, encodedData, flag, options.mode, cred);
 }
+writeFileSync;
 export function appendFileSync(filename, data, arg3) {
     const options = normalizeOptions(arg3, 'utf8', 'a', 0o644);
     const flag = FileFlag.getFileFlag(options.flag);
@@ -140,16 +142,12 @@ export function appendFileSync(filename, data, arg3) {
     const encodedData = typeof data == 'string' ? encode(data) : data;
     return doOp('appendFileSync', true, filename, encodedData, flag, options.mode, cred);
 }
-/**
- * Synchronous `fstat`.
- * `fstat()` is identical to `stat()`, except that the file to be stat-ed is
- * specified by the file descriptor `fd`.
- * @param fd
- * @return [ZenFS.node.fs.Stats]
- */
-export function fstatSync(fd) {
-    return fd2file(fd).statSync();
+appendFileSync;
+export function fstatSync(fd, options) {
+    const stats = fd2file(fd).statSync();
+    return options?.bigint ? BigIntStats.clone(stats) : stats;
 }
+fstatSync;
 /**
  * Synchronous close.
  * @param fd
@@ -158,6 +156,7 @@ export function closeSync(fd) {
     fd2file(fd).closeSync();
     fdMap.delete(fd);
 }
+closeSync;
 /**
  * Synchronous ftruncate.
  * @param fd
@@ -170,6 +169,7 @@ export function ftruncateSync(fd, len = 0) {
     }
     file.truncateSync(len);
 }
+ftruncateSync;
 /**
  * Synchronous fsync.
  * @param fd
@@ -177,6 +177,7 @@ export function ftruncateSync(fd, len = 0) {
 export function fsyncSync(fd) {
     fd2file(fd).syncSync();
 }
+fsyncSync;
 /**
  * Synchronous fdatasync.
  * @param fd
@@ -184,6 +185,7 @@ export function fsyncSync(fd) {
 export function fdatasyncSync(fd) {
     fd2file(fd).datasyncSync();
 }
+fdatasyncSync;
 export function writeSync(fd, arg2, arg3, arg4, arg5) {
     let buffer, offset = 0, length, position;
     if (typeof arg2 === 'string') {
@@ -207,6 +209,7 @@ export function writeSync(fd, arg2, arg3, arg4, arg5) {
     }
     return file.writeSync(buffer, offset, length, position);
 }
+writeSync;
 export function readSync(fd, buffer, opts, length, position) {
     const file = fd2file(fd);
     let offset = opts;
@@ -218,6 +221,7 @@ export function readSync(fd, buffer, opts, length, position) {
     }
     return file.readSync(buffer, offset, length, position);
 }
+readSync;
 /**
  * Synchronous `fchown`.
  * @param fd
@@ -227,6 +231,7 @@ export function readSync(fd, buffer, opts, length, position) {
 export function fchownSync(fd, uid, gid) {
     fd2file(fd).chownSync(uid, gid);
 }
+fchownSync;
 /**
  * Synchronous `fchmod`.
  * @param fd
@@ -236,6 +241,7 @@ export function fchmodSync(fd, mode) {
     const numMode = typeof mode === 'string' ? parseInt(mode, 8) : mode;
     fd2file(fd).chmodSync(numMode);
 }
+fchmodSync;
 /**
  * Change the file timestamps of a file referenced by the supplied file
  * descriptor.
@@ -246,6 +252,7 @@ export function fchmodSync(fd, mode) {
 export function futimesSync(fd, atime, mtime) {
     fd2file(fd).utimesSync(normalizeTime(atime), normalizeTime(mtime));
 }
+futimesSync;
 // DIRECTORY-ONLY METHODS
 /**
  * Synchronous `rmdir`.
@@ -254,35 +261,38 @@ export function futimesSync(fd, atime, mtime) {
 export function rmdirSync(path) {
     return doOp('rmdirSync', true, path, cred);
 }
-/**
- * Synchronous `mkdir`.
- * @param path
- * @param mode defaults to `0777`
- */
-export function mkdirSync(path, mode) {
+rmdirSync;
+export function mkdirSync(path, options) {
+    const mode = typeof options == 'number' || typeof options == 'string' ? options : options?.mode;
+    const recursive = typeof options == 'object' && options?.recursive;
     doOp('mkdirSync', true, path, normalizeMode(mode, 0o777), cred);
 }
-/**
- * Synchronous `readdir`. Reads the contents of a directory.
- * @param path
- * @return [String[]]
- */
-export function readdirSync(path) {
+mkdirSync;
+export function readdirSync(path, options) {
     path = normalizePath(path);
     const entries = doOp('readdirSync', true, path, cred);
-    const points = [...mounts.keys()];
-    for (const point of points) {
-        if (point.startsWith(path)) {
-            const entry = point.slice(path.length);
-            if (entry.includes('/') || entry.length == 0) {
-                // ignore FSs mounted in subdirectories and any FS mounted to `path`.
-                continue;
-            }
-            entries.push(entry);
+    for (const mount of mounts.keys()) {
+        if (!mount.startsWith(path)) {
+            continue;
         }
+        const entry = mount.slice(path.length);
+        if (entry.includes('/') || entry.length == 0) {
+            // ignore FSs mounted in subdirectories and any FS mounted to `path`.
+            continue;
+        }
+        entries.push(entry);
     }
-    return entries;
+    return entries.map((entry) => {
+        if (typeof options == 'object' && options?.withFileTypes) {
+            return new Dirent(entry, statSync(join(path, entry)));
+        }
+        if (options == 'buffer' || (typeof options == 'object' && options.encoding == 'buffer')) {
+            return encode(entry);
+        }
+        return entry;
+    });
 }
+readdirSync;
 // SYMLINK METHODS
 /**
  * Synchronous `link`.
@@ -293,6 +303,7 @@ export function linkSync(srcpath, dstpath) {
     dstpath = normalizePath(dstpath);
     return doOp('linkSync', false, srcpath, dstpath, cred);
 }
+linkSync;
 /**
  * Synchronous `symlink`.
  * @param srcpath
@@ -306,14 +317,12 @@ export function symlinkSync(srcpath, dstpath, type) {
     dstpath = normalizePath(dstpath);
     return doOp('symlinkSync', false, srcpath, dstpath, type, cred);
 }
-/**
- * Synchronous readlink.
- * @param path
- * @return [String]
- */
-export function readlinkSync(path) {
-    return doOp('readlinkSync', false, path, cred);
+symlinkSync;
+export function readlinkSync(path, options) {
+    const value = doOp('readlinkSync', false, path, cred);
+    return encode(value, typeof options == 'object' ? options.encoding : options);
 }
+readlinkSync;
 // PROPERTY OPERATIONS
 /**
  * Synchronous `chown`.
@@ -324,6 +333,7 @@ export function readlinkSync(path) {
 export function chownSync(path, uid, gid) {
     doOp('chownSync', true, path, uid, gid, cred);
 }
+chownSync;
 /**
  * Synchronous `lchown`.
  * @param path
@@ -333,6 +343,7 @@ export function chownSync(path, uid, gid) {
 export function lchownSync(path, uid, gid) {
     doOp('chownSync', false, path, uid, gid, cred);
 }
+lchownSync;
 /**
  * Synchronous `chmod`.
  * @param path
@@ -345,6 +356,7 @@ export function chmodSync(path, mode) {
     }
     doOp('chmodSync', true, path, numMode, cred);
 }
+chmodSync;
 /**
  * Synchronous `lchmod`.
  * @param path
@@ -357,6 +369,7 @@ export function lchmodSync(path, mode) {
     }
     doOp('chmodSync', false, path, numMode, cred);
 }
+lchmodSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -366,6 +379,7 @@ export function lchmodSync(path, mode) {
 export function utimesSync(path, atime, mtime) {
     doOp('utimesSync', true, path, normalizeTime(atime), normalizeTime(mtime), cred);
 }
+utimesSync;
 /**
  * Change file timestamps of the file referenced by the supplied path.
  * @param path
@@ -375,15 +389,8 @@ export function utimesSync(path, atime, mtime) {
 export function lutimesSync(path, atime, mtime) {
     doOp('utimesSync', false, path, normalizeTime(atime), normalizeTime(mtime), cred);
 }
-/**
- * Synchronous `realpath`.
- * @param path
- * @param cache An object literal of mapped paths that can be used to
- *   force a specific path resolution or avoid additional `fs.stat` calls for
- *   known real paths.
- * @return [String]
- */
-export function realpathSync(path, cache = {}) {
+lutimesSync;
+export function realpathSync(path, options) {
     path = normalizePath(path);
     const { fs, path: resolvedPath, mountPoint } = resolveFS(path);
     try {
@@ -398,6 +405,7 @@ export function realpathSync(path, cache = {}) {
         throw fixError(e, { [resolvedPath]: path });
     }
 }
+realpathSync;
 /**
  * Synchronous `access`.
  * @param path
@@ -406,3 +414,28 @@ export function realpathSync(path, cache = {}) {
 export function accessSync(path, mode = 0o600) {
     return doOp('accessSync', true, path, mode, cred);
 }
+accessSync;
+export function rmSync(path) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+rmSync;
+export function mkdtempSync(prefix, options) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+mkdtempSync;
+export function copyFileSync(src, dest, flags) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+copyFileSync;
+export function readvSync(fd, buffers, position) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+readvSync;
+export function writevSync(fd, buffers, position) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+writevSync;
+export function opendirSync(path, options) {
+    throw new ApiError(ErrorCode.ENOTSUP);
+}
+opendirSync;

package/dist/file.d.ts

@@ -29,18 +29,24 @@ export declare class FileFlag {
     private static validFlagStrs;
     /**
      * Get an object representing the given file flag.
-     * @param modeStr The string representing the flag
+     * @param flag The string or number representing the flag
      * @return The FileFlag object representing the flag
      * @throw when the flag string is invalid
      */
-    static getFileFlag(flagStr: string): FileFlag;
+    static getFileFlag(flag: string | number): FileFlag;
     private flagStr;
     /**
      * This should never be called directly.
-     * @param modeStr The string representing the mode
-     * @throw when the mode string is invalid
+     * @param flag The string or number representing the flag
+     * @throw when the flag is invalid
      */
-    constructor(flagStr: string);
+    constructor(flag: string | number);
+    /**
+     * @param flag The number representing the flag
+     * @return The string representing the flag
+     * @throw when the flag number is invalid
+     */
+    static StringFromNumber(flag: number): string;
     /**
      * Get the underlying flag string for this flag.
      */

package/dist/file.js

@@ -1,15 +1,7 @@
-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());
-    });
-};
 import { ApiError, ErrorCode } from './ApiError.js';
 import { Stats } from './stats.js';
 import { getMount } from './emulation/shared.js';
+import { O_RDONLY, O_WRONLY, O_RDWR, O_CREAT, O_EXCL, O_TRUNC, O_APPEND, O_SYNC } from './emulation/constants.js';
 export var ActionType;
 (function (ActionType) {
     // Indicates that the code should not do anything.
@@ -42,26 +34,65 @@ export var ActionType;
 export class FileFlag {
     /**
      * Get an object representing the given file flag.
-     * @param modeStr The string representing the flag
+     * @param flag The string or number representing the flag
      * @return The FileFlag object representing the flag
      * @throw when the flag string is invalid
      */
-    static getFileFlag(flagStr) {
+    static getFileFlag(flag) {
         // Check cache first.
-        if (!FileFlag.flagCache.has(flagStr)) {
-            FileFlag.flagCache.set(flagStr, new FileFlag(flagStr));
+        if (!FileFlag.flagCache.has(flag)) {
+            FileFlag.flagCache.set(flag, new FileFlag(flag));
         }
-        return FileFlag.flagCache.get(flagStr);
+        return FileFlag.flagCache.get(flag);
     }
     /**
      * This should never be called directly.
-     * @param modeStr The string representing the mode
-     * @throw when the mode string is invalid
+     * @param flag The string or number representing the flag
+     * @throw when the flag is invalid
      */
-    constructor(flagStr) {
-        this.flagStr = flagStr;
-        if (FileFlag.validFlagStrs.indexOf(flagStr) < 0) {
-            throw new ApiError(ErrorCode.EINVAL, 'Invalid flag: ' + flagStr);
+    constructor(flag) {
+        if (typeof flag === 'number') {
+            flag = FileFlag.StringFromNumber(flag);
+        }
+        if (FileFlag.validFlagStrs.indexOf(flag) < 0) {
+            throw new ApiError(ErrorCode.EINVAL, 'Invalid flag string: ' + flag);
+        }
+        this.flagStr = flag;
+    }
+    /**
+     * @param flag The number representing the flag
+     * @return The string representing the flag
+     * @throw when the flag number is invalid
+     */
+    static StringFromNumber(flag) {
+        // based on https://github.com/nodejs/node/blob/abbdc3efaa455e6c907ebef5409ac8b0f222f969/lib/internal/fs/utils.js#L619
+        switch (flag) {
+            case O_RDONLY:
+                return 'r';
+            case O_RDONLY | O_SYNC:
+                return 'rs';
+            case O_RDWR:
+                return 'r+';
+            case O_RDWR | O_SYNC:
+                return 'rs+';
+            case O_TRUNC | O_CREAT | O_WRONLY:
+                return 'w';
+            case O_TRUNC | O_CREAT | O_WRONLY | O_EXCL:
+                return 'wx';
+            case O_TRUNC | O_CREAT | O_RDWR:
+                return 'w+';
+            case O_TRUNC | O_CREAT | O_RDWR | O_EXCL:
+                return 'wx+';
+            case O_APPEND | O_CREAT | O_WRONLY:
+                return 'a';
+            case O_APPEND | O_CREAT | O_WRONLY | O_EXCL:
+                return 'ax';
+            case O_APPEND | O_CREAT | O_RDWR:
+                return 'a+';
+            case O_APPEND | O_CREAT | O_RDWR | O_EXCL:
+                return 'ax+';
+            default:
+                throw new ApiError(ErrorCode.EINVAL, 'Invalid flag number: ' + flag);
         }
     }
     /**
@@ -156,42 +187,32 @@ FileFlag.validFlagStrs = ['r', 'r+', 'rs', 'rs+', 'w', 'wx', 'w+', 'wx+', 'a', '
  * object.
  */
 export class BaseFile {
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async sync() {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     syncSync() {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    datasync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.sync();
-        });
+    async datasync() {
+        return this.sync();
     }
     datasyncSync() {
         return this.syncSync();
     }
-    chown(uid, gid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async chown(uid, gid) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     chownSync(uid, gid) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    chmod(mode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async chmod(mode) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     chmodSync(mode) {
         throw new ApiError(ErrorCode.ENOTSUP);
     }
-    utimes(atime, mtime) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ApiError(ErrorCode.ENOTSUP);
-        });
+    async utimes(atime, mtime) {
+        throw new ApiError(ErrorCode.ENOTSUP);
     }
     utimesSync(atime, mtime) {
         throw new ApiError(ErrorCode.ENOTSUP);
@@ -294,10 +315,8 @@ export class PreloadFile extends BaseFile {
      * class.
      * @param [Function(ZenFS.ApiError)] cb
      */
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.syncSync();
-        });
+    async sync() {
+        this.syncSync();
     }
     /**
      * **Core**: Synchronous sync.
@@ -310,10 +329,8 @@ export class PreloadFile extends BaseFile {
      * class.
      * @param [Function(ZenFS.ApiError)] cb
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.closeSync();
-        });
+    async close() {
+        this.closeSync();
     }
     /**
      * **Core**: Synchronous close.
@@ -325,10 +342,8 @@ export class PreloadFile extends BaseFile {
      * Asynchronous `stat`.
      * @param [Function(ZenFS.ApiError, ZenFS.node.fs.Stats)] cb
      */
-    stat() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return Stats.clone(this._stat);
-        });
+    async stat() {
+        return Stats.clone(this._stat);
     }
     /**
      * Synchronous `stat`.
@@ -387,10 +402,8 @@ export class PreloadFile extends BaseFile {
      * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Uint8Array)]
      *   cb The number specifies the number of bytes written into the file.
      */
-    write(buffer, offset, length, position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.writeSync(buffer, offset, length, position);
-        });
+    async write(buffer, offset, length, position) {
+        return this.writeSync(buffer, offset, length, position);
     }
     /**
      * Write buffer to the file.
@@ -446,10 +459,8 @@ export class PreloadFile extends BaseFile {
      * @param [Function(ZenFS.ApiError, Number, ZenFS.node.Uint8Array)] cb The
      *   number is the number of bytes read
      */
-    read(buffer, offset, length, position) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return { bytesRead: this.readSync(buffer, offset, length, position), buffer };
-        });
+    async read(buffer, offset, length, position) {
+        return { bytesRead: this.readSync(buffer, offset, length, position), buffer };
     }
     /**
      * Read data from the file.
@@ -483,10 +494,8 @@ export class PreloadFile extends BaseFile {
      * Asynchronous `fchmod`.
      * @param [Number|String] mode
      */
-    chmod(mode) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.chmodSync(mode);
-        });
+    async chmod(mode) {
+        this.chmodSync(mode);
     }
     /**
      * Synchronous `fchmod`.
@@ -505,10 +514,8 @@ export class PreloadFile extends BaseFile {
      * @param [Number] uid
      * @param [Number] gid
      */
-    chown(uid, gid) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.chownSync(uid, gid);
-        });
+    async chown(uid, gid) {
+        this.chownSync(uid, gid);
     }
     /**
      * Synchronous `fchown`.
@@ -545,10 +552,8 @@ export class NoSyncFile extends PreloadFile {
      * Asynchronous sync. Doesn't do anything, simply calls the cb.
      * @param [Function(ZenFS.ApiError)] cb
      */
-    sync() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async sync() {
+        return;
     }
     /**
      * Synchronous sync. Doesn't do anything.
@@ -560,10 +565,8 @@ export class NoSyncFile extends PreloadFile {
      * Asynchronous close. Doesn't do anything, simply calls the cb.
      * @param [Function(ZenFS.ApiError)] cb
      */
-    close() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return;
-        });
+    async close() {
+        return;
     }
     /**
      * Synchronous close. Doesn't do anything.

package/dist/filesystem.d.ts

@@ -2,9 +2,9 @@ import { ApiError } from './ApiError.js';
 import { Stats } from './stats.js';
 import { File, FileFlag } from './file.js';
 import { Cred } from './cred.js';
-export type BFSOneArgCallback = (e?: ApiError) => unknown;
-export type BFSCallback<T> = (e?: ApiError, rv?: T) => unknown;
-export type BFSThreeArgCallback<T, U> = (e?: ApiError, arg1?: T, arg2?: U) => unknown;
+export type NoArgCallback = (e?: ApiError) => unknown;
+export type TwoArgCallback<T> = (e?: ApiError, rv?: T) => unknown;
+export type ThreeArgCallback<T, U> = (e?: ApiError, arg1?: T, arg2?: U) => unknown;
 export type FileContents = Uint8Array | string;
 /**
  * Metadata about a FileSystem