pwd-fs 3.3.5 → 3.5.0

package/dist/powered-file-system/realpath.d.ts

@@ -0,0 +1,13 @@
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
+/**
+ * Resolves a path to its canonical absolute location.
+ */
+export declare function realpath(this: PoweredFileSystem, src: string, options: SyncOption & {
+    encoding?: BufferEncoding;
+}): string;
+export declare function realpath(this: PoweredFileSystem, src: string, options?: AsyncOption & {
+    encoding?: BufferEncoding;
+}): Promise<string>;
+export declare function realpath(this: PoweredFileSystem, src: string, options?: MaybeSyncOption & {
+    encoding?: BufferEncoding;
+}): string | Promise<string>;

package/dist/powered-file-system/realpath.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.realpath = realpath;
+const node_fs_1 = __importDefault(require("node:fs"));
+function realpath(src, options) {
+    const { sync = false, encoding = 'utf8' } = options ?? {};
+    if (sync) {
+        return node_fs_1.default.realpathSync(this.resolve(src), { encoding });
+    }
+    return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        node_fs_1.default.realpath(src, { encoding }, (err, resolved) => {
+            if (err) {
+                return reject(err);
+            }
+            resolve(resolved);
+        });
+    });
+}

package/dist/powered-file-system/realpath.test.d.ts

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

package/dist/powered-file-system/realpath.test.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_path_1 = __importDefault(require("node:path"));
+const chance_1 = __importDefault(require("chance"));
+const node_test_1 = require("node:test");
+const index_1 = require("../index");
+const test_utils_1 = require("../test-utils");
+/**
+ * Verifies canonical path resolution through symbolic links.
+ */
+(0, node_test_1.describe)('realpath(src [, options])', () => {
+    const chance = new chance_1.default();
+    let tmpDir = '';
+    (0, node_test_1.beforeEach)(() => {
+        tmpDir = (0, test_utils_1.createTmpDir)();
+        (0, test_utils_1.fmock)({
+            [node_path_1.default.join(tmpDir, 'tings.txt')]: {
+                type: 'file',
+                data: chance.string()
+            },
+            [node_path_1.default.join(tmpDir, 'flexapp')]: {
+                type: 'symlink',
+                target: node_path_1.default.join(tmpDir, 'tings.txt')
+            }
+        });
+    });
+    (0, node_test_1.afterEach)(() => {
+        (0, test_utils_1.restore)(tmpDir);
+    });
+    (0, node_test_1.it)('Positive: Resolves the canonical target path', async () => {
+        const target = await index_1.pfs.realpath(node_path_1.default.join(tmpDir, 'flexapp'));
+        (0, node_assert_1.default)(target === node_path_1.default.join(tmpDir, 'tings.txt'));
+    });
+    (0, node_test_1.it)('[sync] Positive: Resolves the canonical target path', () => {
+        const target = index_1.pfs.realpath(node_path_1.default.join(tmpDir, 'flexapp'), {
+            sync: true
+        });
+        (0, node_assert_1.default)(target === node_path_1.default.join(tmpDir, 'tings.txt'));
+    });
+});

package/dist/powered-file-system/remove.d.ts

@@ -1,7 +1,7 @@
-import type { PoweredFileSystem } from '../powered-file-system';
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
 /**
- * Removes a path relative to the instance root, preferring native recursive APIs when available.
+ * Removes a path relative to the instance base path.
  */
-export declare function remove<T extends boolean = false>(this: PoweredFileSystem, src: string, options?: {
-    sync?: T;
-}): T extends true ? void : Promise<void>;
+export declare function remove(this: PoweredFileSystem, src: string, options: SyncOption): void;
+export declare function remove(this: PoweredFileSystem, src: string, options?: AsyncOption): Promise<void>;
+export declare function remove(this: PoweredFileSystem, src: string, options?: MaybeSyncOption): void | Promise<void>;

package/dist/powered-file-system/remove.js

@@ -1,36 +1,27 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.remove = remove;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 const recurse_io_1 = require("../recurse-io");
 const recurse_io_sync_1 = require("../recurse-io-sync");
-/**
- * Removes a path relative to the instance root, preferring native recursive APIs when available.
- */
 function remove(src, options) {
-    src = node_path_1.default.resolve(this.pwd, src);
     const { sync = false } = options ?? {};
     if (sync) {
-        (0, recurse_io_sync_1.removeSync)(src);
-        return undefined;
+        (0, recurse_io_sync_1.removeSync)(this.resolve(src));
+        return;
     }
     return new Promise((resolve, reject) => {
-        const callback = (err) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
+        (0, recurse_io_1.remove)(src, (err) => {
             if (err) {
                 return reject(err);
             }
             resolve();
-        };
-        if ('rm' in node_fs_1.default) {
-            // Prefer the native recursive removal when the runtime supports it.
-            node_fs_1.default.rm(src, { recursive: true }, callback);
-        }
-        else {
-            (0, recurse_io_1.remove)(src, callback);
-        }
+        });
     });
 }

package/dist/powered-file-system/rename.d.ts

@@ -1,7 +1,7 @@
-import type { PoweredFileSystem } from '../powered-file-system';
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
 /**
- * Resolves both paths against the instance root before delegating to Node's rename API.
+ * Resolves both paths against the instance base path before delegating to Node's rename API.
  */
-export declare function rename<T extends boolean = false>(this: PoweredFileSystem, src: string, dest: string, options?: {
-    sync?: T;
-}): T extends true ? void : Promise<void>;
+export declare function rename(this: PoweredFileSystem, src: string, dest: string, options: SyncOption): void;
+export declare function rename(this: PoweredFileSystem, src: string, dest: string, options?: AsyncOption): Promise<void>;
+export declare function rename(this: PoweredFileSystem, src: string, dest: string, options?: MaybeSyncOption): void | Promise<void>;

package/dist/powered-file-system/rename.js

@@ -5,19 +5,23 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rename = rename;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Resolves both paths against the instance root before delegating to Node's rename API.
- */
 function rename(src, dest, options) {
-    src = node_path_1.default.resolve(this.pwd, src);
-    dest = node_path_1.default.resolve(this.pwd, dest);
     const { sync = false } = options ?? {};
     if (sync) {
+        src = this.resolve(src);
+        dest = this.resolve(dest);
         node_fs_1.default.renameSync(src, dest);
-        return undefined;
+        return;
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+            dest = this.resolve(dest);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         node_fs_1.default.rename(src, dest, (err) => {
             if (err) {
                 return reject(err);

package/dist/powered-file-system/stat.d.ts

@@ -1,7 +1,7 @@
-import type { PoweredFileSystem, Stats } from '../powered-file-system';
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, Stats, SyncOption } from '../powered-file-system';
 /**
  * Returns `lstat` data so symlinks are reported as links instead of followed targets.
  */
-export declare function stat<T extends boolean = false>(this: PoweredFileSystem, src: string, options?: {
-    sync?: T;
-}): T extends true ? Stats : Promise<Stats>;
+export declare function stat(this: PoweredFileSystem, src: string, options: SyncOption): Stats;
+export declare function stat(this: PoweredFileSystem, src: string, options?: AsyncOption): Promise<Stats>;
+export declare function stat(this: PoweredFileSystem, src: string, options?: MaybeSyncOption): Stats | Promise<Stats>;

package/dist/powered-file-system/stat.js

@@ -5,17 +5,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stat = stat;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Returns `lstat` data so symlinks are reported as links instead of followed targets.
- */
 function stat(src, options) {
     const { sync = false } = options ?? {};
-    src = node_path_1.default.resolve(this.pwd, src);
     if (sync) {
-        return node_fs_1.default.lstatSync(src);
+        return node_fs_1.default.lstatSync(this.resolve(src));
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         node_fs_1.default.lstat(src, (err, stats) => {
             if (err) {
                 return reject(err);

package/dist/powered-file-system/symlink.d.ts

@@ -1,4 +1,4 @@
-import type { PoweredFileSystem } from '../powered-file-system';
-export declare function symlink<T extends boolean = false>(this: PoweredFileSystem, src: string, dest: string, options?: {
-    sync?: T;
-}): T extends true ? void : Promise<void>;
+import type { AsyncOption, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
+export declare function symlink(this: PoweredFileSystem, src: string, dest: string, options: SyncOption): void;
+export declare function symlink(this: PoweredFileSystem, src: string, dest: string, options?: AsyncOption): Promise<void>;
+export declare function symlink(this: PoweredFileSystem, src: string, dest: string, options?: MaybeSyncOption): void | Promise<void>;

package/dist/powered-file-system/symlink.js

@@ -5,7 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.symlink = symlink;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
 /**
  * Windows requires an explicit link type. Non-Windows platforms infer it.
  */
@@ -17,15 +16,23 @@ function resolveSymlinkType(src) {
     return stats.isDirectory() ? 'junction' : 'file';
 }
 function symlink(src, dest, options) {
-    src = node_path_1.default.resolve(this.pwd, src);
-    dest = node_path_1.default.resolve(this.pwd, dest);
     const { sync = false } = options ?? {};
     if (sync) {
+        src = this.resolve(src);
+        dest = this.resolve(dest);
         const type = resolveSymlinkType(src);
         node_fs_1.default.symlinkSync(src, dest, type);
-        return undefined;
+        return;
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+            dest = this.resolve(dest);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         if (process.platform === 'win32') {
             node_fs_1.default.lstat(src, (err, stats) => {
                 if (err) {

package/dist/powered-file-system/test.d.ts

@@ -1,8 +1,13 @@
-import type { Mode, PoweredFileSystem } from '../powered-file-system';
+import type { AsyncOption, MaybeSyncOption, Mode, PoweredFileSystem, SyncOption } from '../powered-file-system';
 /**
- * Thin wrapper around `fs.access` that resolves paths against the instance root.
+ * Thin wrapper around `fs.access` that resolves paths against the instance base path.
  */
-export declare function test<T extends boolean = false>(this: PoweredFileSystem, src: string, options?: {
-    sync?: T;
+export declare function test(this: PoweredFileSystem, src: string, options: SyncOption & {
     flag?: Mode;
-}): T extends true ? boolean : Promise<boolean>;
+}): boolean;
+export declare function test(this: PoweredFileSystem, src: string, options?: AsyncOption & {
+    flag?: Mode;
+}): Promise<boolean>;
+export declare function test(this: PoweredFileSystem, src: string, options?: MaybeSyncOption & {
+    flag?: Mode;
+}): boolean | Promise<boolean>;

package/dist/powered-file-system/test.js

@@ -5,16 +5,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.test = test;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Thin wrapper around `fs.access` that resolves paths against the instance root.
- */
 function test(src, options) {
     const { sync = false, flag = 'e' } = options ?? {};
     const mode = this.constants[flag];
-    src = node_path_1.default.resolve(this.pwd, src);
     if (sync) {
         try {
+            src = this.resolve(src);
             node_fs_1.default.accessSync(src, mode);
             return true;
         }
@@ -23,6 +19,13 @@ function test(src, options) {
         }
     }
     return new Promise((resolve) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch {
+            resolve(false);
+            return;
+        }
         node_fs_1.default.access(src, mode, (err) => {
             resolve(!err);
         });

package/dist/powered-file-system/write.d.ts

@@ -1,10 +1,13 @@
-import type { Flag, PoweredFileSystem } from '../powered-file-system';
-/**
- * Writes a file relative to `pwd` and then reapplies the computed permissions explicitly.
- */
-export declare function write<T extends boolean = false>(this: PoweredFileSystem, src: string, data: Buffer | string, options?: {
-    sync?: T;
+import type { AsyncOption, Flag, MaybeSyncOption, PoweredFileSystem, SyncOption } from '../powered-file-system';
+type WriteOptions = {
     encoding?: BufferEncoding | null;
     umask?: number;
     flag?: Flag;
-}): T extends true ? void : Promise<void>;
+};
+/**
+ * Writes a file relative to `pwd` and then reapplies the computed permissions explicitly.
+ */
+export declare function write(this: PoweredFileSystem, src: string, data: Buffer | string, options: SyncOption & WriteOptions): void;
+export declare function write(this: PoweredFileSystem, src: string, data: Buffer | string, options?: AsyncOption & WriteOptions): Promise<void>;
+export declare function write(this: PoweredFileSystem, src: string, data: Buffer | string, options?: MaybeSyncOption & WriteOptions): void | Promise<void>;
+export {};

package/dist/powered-file-system/write.js

@@ -5,21 +5,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.write = write;
 const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-/**
- * Writes a file relative to `pwd` and then reapplies the computed permissions explicitly.
- */
 function write(src, data, options) {
     const { sync = false, encoding = 'utf8', umask = 0o000, flag = 'w', } = options ?? {};
-    src = node_path_1.default.resolve(this.pwd, src);
     const mode = 0o666 & ~umask;
     if (sync) {
+        src = this.resolve(src);
         // Apply chmod explicitly so the final mode is deterministic across runtimes.
         node_fs_1.default.writeFileSync(src, data, { encoding, mode, flag });
         node_fs_1.default.chmodSync(src, mode);
-        return undefined;
+        return;
     }
     return new Promise((resolve, reject) => {
+        try {
+            src = this.resolve(src);
+        }
+        catch (err) {
+            reject(err);
+            return;
+        }
         node_fs_1.default.writeFile(src, data, { encoding, mode, flag }, (err) => {
             if (err) {
                 return reject(err);

package/dist/powered-file-system.d.ts

@@ -6,6 +6,28 @@ import { bitmask } from './bitmask';
 export type Mode = keyof IConstants;
 export type Flag = Extract<fs.OpenMode, string>;
 export type Stats = fs.Stats;
+export type CopyFilter = (src: string, dest: string) => boolean;
+export type SyncResult<T extends boolean, TResult> = T extends true ? TResult : Promise<TResult>;
+export type SyncOption = {
+    sync: true;
+};
+export type AsyncOption = {
+    sync?: false;
+};
+export type MaybeSyncOption = {
+    sync?: boolean;
+};
+export type ReadResult<TEncoding> = TEncoding extends null ? Buffer : string;
+export type ReaddirResult<TEncoding> = TEncoding extends null ? Buffer[] : string[];
+export type ReadOptions<TSync extends boolean = boolean, TEncoding extends BufferEncoding | null = BufferEncoding> = {
+    sync?: TSync;
+    encoding?: TEncoding;
+    flag?: Flag;
+};
+export type ReaddirOptions<TSync extends boolean = boolean, TEncoding extends BufferEncoding | null = BufferEncoding> = {
+    sync?: TSync;
+    encoding?: TEncoding;
+};
 export * from './bitmask';
 export interface IConstants {
     e: number;
@@ -16,8 +38,7 @@ export interface IConstants {
 /**
  * Path-aware wrapper around Node's file system APIs.
  *
- * All relative paths are resolved against `pwd`, which makes the instance
- * suitable for sandboxed or virtual working-directory workflows.
+ * Relative paths are resolved against `pwd`; absolute paths are preserved.
  */
 export declare class PoweredFileSystem {
     readonly pwd: string;
@@ -33,95 +54,144 @@ export declare class PoweredFileSystem {
      * @param pwd Base directory used to resolve all relative paths.
      */
     constructor(pwd?: string);
+    /**
+     * Resolves relative paths against `pwd` while preserving absolute paths.
+     */
+    resolve(src: string): string;
     /**
      * Checks whether the given path is accessible with the requested mode.
      */
-    test<T extends boolean = false>(src: string, options?: {
-        sync?: T;
+    test(src: string, options: SyncOption & {
+        flag?: Mode;
+    }): boolean;
+    test(src: string, options?: AsyncOption & {
         flag?: Mode;
-    }): T extends true ? boolean : Promise<boolean>;
+    }): Promise<boolean>;
     /**
      * Returns `lstat` information for a path.
      */
-    stat<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-    }): T extends true ? Stats : Promise<Stats>;
+    stat(src: string, options: SyncOption): Stats;
+    stat(src: string, options?: AsyncOption): Promise<Stats>;
     /**
      * Applies a mode recursively to a file or directory tree.
      */
-    chmod<T extends boolean = false>(src: string, mode: number, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    chmod(src: string, mode: number, options: SyncOption): void;
+    chmod(src: string, mode: number, options?: AsyncOption): Promise<void>;
     /**
      * Applies ownership recursively to a file or directory tree.
      */
-    chown<T extends boolean = false>(src: string, options?: {
-        sync?: T;
+    chown(src: string, options: SyncOption & {
         uid?: number;
         gid?: number;
-    }): T extends true ? void : Promise<void>;
+    }): void;
+    chown(src: string, options?: AsyncOption & {
+        uid?: number;
+        gid?: number;
+    }): Promise<void>;
     /**
      * Creates a symbolic link from `dest` to `src`.
      */
-    symlink<T extends boolean = false>(src: string, dest: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    symlink(src: string, dest: string, options: SyncOption): void;
+    symlink(src: string, dest: string, options?: AsyncOption): Promise<void>;
     /**
      * Copies `src` into the destination directory.
      */
-    copy<T extends boolean = false>(src: string, dest: string, options?: {
-        sync?: T;
+    copy(src: string, dest: string, options: SyncOption & {
+        umask?: number;
+        overwrite?: boolean;
+        filter?: CopyFilter;
+    }): void;
+    copy(src: string, dest: string, options?: AsyncOption & {
         umask?: number;
-    }): T extends true ? void : Promise<void>;
+        overwrite?: boolean;
+        filter?: CopyFilter;
+    }): Promise<void>;
     /**
      * Renames or moves a file system node.
      */
-    rename<T extends boolean = false>(src: string, dest: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    rename(src: string, dest: string, options: SyncOption): void;
+    rename(src: string, dest: string, options?: AsyncOption): Promise<void>;
     /**
      * Removes a file system node recursively.
      */
-    remove<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-    }): T extends true ? void : Promise<void>;
+    remove(src: string, options: SyncOption): void;
+    remove(src: string, options?: AsyncOption): Promise<void>;
     /**
-     * Reads a file relative to the current instance root.
+     * Removes all directory entries while preserving the directory itself.
      */
-    read<T extends boolean = false>(src: string, options?: {
-        sync?: T;
-        encoding?: BufferEncoding | null;
-        flag?: Flag;
-    }): T extends true ? string | Buffer : Promise<string | Buffer>;
+    emptyDir(src: string, options: SyncOption): void;
+    emptyDir(src: string, options?: AsyncOption): Promise<void>;
+    /**
+     * Reads a file relative to the current instance path.
+     */
+    read(src: string, options: SyncOption & ReadOptions<true, null> & {
+        encoding: null;
+    }): Buffer;
+    read(src: string, options: SyncOption & ReadOptions<true, BufferEncoding>): string;
+    read(src: string, options: AsyncOption & ReadOptions<false, null> & {
+        encoding: null;
+    }): Promise<Buffer>;
+    read(src: string, options?: AsyncOption & ReadOptions<false, BufferEncoding>): Promise<string>;
     /**
      * Writes a file and applies the resulting permissions explicitly.
      */
-    write<T extends boolean = false>(src: string, data: Buffer | string, options?: {
-        sync?: T;
+    write(src: string, data: Buffer | string, options: SyncOption & {
         encoding?: BufferEncoding | null;
         umask?: number;
         flag?: Flag;
-    }): T extends true ? void : Promise<void>;
+    }): void;
+    write(src: string, data: Buffer | string, options?: AsyncOption & {
+        encoding?: BufferEncoding | null;
+        umask?: number;
+        flag?: Flag;
+    }): Promise<void>;
     /**
      * @deprecated Use `write(..., { flag: 'a' })` instead.
      */
-    append<T extends boolean = false>(src: string, data: Buffer | string, options?: {
-        sync?: T;
+    append(src: string, data: Buffer | string, options: SyncOption & {
         encoding?: BufferEncoding | null;
         umask?: number;
-    }): T extends true ? void : Promise<void>;
+    }): void;
+    append(src: string, data: Buffer | string, options?: AsyncOption & {
+        encoding?: BufferEncoding | null;
+        umask?: number;
+    }): Promise<void>;
     /**
-     * Lists directory entries relative to the current instance root.
+     * Lists directory entries relative to the current instance path.
      */
-    readdir<T extends boolean = false>(dir: string, options?: {
-        sync?: T;
-        encoding?: BufferEncoding | null;
-    }): T extends true ? string[] : Promise<string[]>;
+    readdir(dir: string, options: SyncOption & ReaddirOptions<true, null> & {
+        encoding: null;
+    }): Buffer[];
+    readdir(dir: string, options: SyncOption & ReaddirOptions<true, BufferEncoding>): string[];
+    readdir(dir: string, options: AsyncOption & ReaddirOptions<false, null> & {
+        encoding: null;
+    }): Promise<Buffer[]>;
+    readdir(dir: string, options?: AsyncOption & ReaddirOptions<false, BufferEncoding>): Promise<string[]>;
     /**
-     * Creates a directory tree relative to the current instance root.
+     * Resolves the target of a symbolic link.
      */
-    mkdir<T extends boolean = false>(dir: string, options?: {
-        sync?: T;
+    readlink(src: string, options: SyncOption & {
+        encoding?: BufferEncoding;
+    }): string;
+    readlink(src: string, options?: AsyncOption & {
+        encoding?: BufferEncoding;
+    }): Promise<string>;
+    /**
+     * Resolves a path to its canonical absolute location.
+     */
+    realpath(src: string, options: SyncOption & {
+        encoding?: BufferEncoding;
+    }): string;
+    realpath(src: string, options?: AsyncOption & {
+        encoding?: BufferEncoding;
+    }): Promise<string>;
+    /**
+     * Creates a directory tree relative to the current instance path.
+     */
+    mkdir(dir: string, options: SyncOption & {
+        umask?: number;
+    }): void;
+    mkdir(dir: string, options?: AsyncOption & {
         umask?: number;
-    }): T extends true ? void : Promise<void>;
+    }): Promise<void>;
 }