@runlith/tagma 0.0.0-stage → 0.1.0

package/types/node/fs.d.ts

@@ -0,0 +1,1038 @@
+declare module "node:fs" {
+    import { NonSharedBuffer } from "node:buffer";
+    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
+    import { FileHandle } from "node:fs/promises";
+    import * as stream from "node:stream";
+    import { URL } from "node:url";
+    type PathLike = string | Buffer | URL;
+    type PathOrFileDescriptor = PathLike | number;
+    type TimeLike = string | number | Date;
+    type NoParamCallback = (err: NodeJS.ErrnoException | null) => void;
+    type BufferEncodingOption = "buffer" | {
+        encoding: "buffer";
+    };
+    interface ObjectEncodingOptions {
+        encoding?: BufferEncoding | null | undefined;
+    }
+    type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
+    type OpenMode = number | string;
+    type Mode = number | string;
+    interface StatsBase<T> {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isSymbolicLink(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+        dev: T;
+        ino: T;
+        mode: T;
+        nlink: T;
+        uid: T;
+        gid: T;
+        rdev: T;
+        size: T;
+        blksize: T;
+        blocks: T;
+        atimeMs: T;
+        mtimeMs: T;
+        ctimeMs: T;
+        birthtimeMs: T;
+        atime: Date;
+        mtime: Date;
+        ctime: Date;
+        birthtime: Date;
+    }
+    interface Stats extends StatsBase<number> {
+    }
+    class Stats {
+        private constructor();
+    }
+    interface StatsFsBase<T> {
+        type: T;
+        bsize: T;
+        blocks: T;
+        bfree: T;
+        bavail: T;
+        files: T;
+        ffree: T;
+    }
+    interface StatsFs extends StatsFsBase<number> {
+    }
+    class StatsFs {
+    }
+    interface BigIntStatsFs extends StatsFsBase<bigint> {
+    }
+    interface StatFsOptions {
+        bigint?: boolean | undefined;
+    }
+    class Dirent<Name extends string | Buffer = string> {
+        isFile(): boolean;
+        isDirectory(): boolean;
+        isBlockDevice(): boolean;
+        isCharacterDevice(): boolean;
+        isSymbolicLink(): boolean;
+        isFIFO(): boolean;
+        isSocket(): boolean;
+        name: Name;
+        parentPath: string;
+    }
+    class Dir implements AsyncIterable<Dirent> {
+        readonly path: string;
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<Dirent>;
+        close(): Promise<void>;
+        close(cb: NoParamCallback): void;
+        closeSync(): void;
+        read(): Promise<Dirent | null>;
+        read(cb: (err: NodeJS.ErrnoException | null, dirEnt: Dirent | null) => void): void;
+        readSync(): Dirent | null;
+        [Symbol.asyncDispose](): Promise<void>;
+        [Symbol.dispose](): void;
+    }
+    interface StatWatcher extends EventEmitter {
+        ref(): this;
+        unref(): this;
+    }
+    interface FSWatcherEventMap {
+        "change": [
+            eventType: string,
+            filename: string | NonSharedBuffer
+        ];
+        "close": [
+        ];
+        "error": [
+            error: Error
+        ];
+    }
+    interface FSWatcher extends InternalEventEmitter<FSWatcherEventMap> {
+        close(): void;
+        ref(): this;
+        unref(): this;
+    }
+    interface ReadStreamEventMap extends stream.ReadableEventMap {
+        "close": [
+        ];
+        "data": [
+            chunk: string | NonSharedBuffer
+        ];
+        "open": [
+            fd: number
+        ];
+        "ready": [
+        ];
+    }
+    class ReadStream extends stream.Readable {
+        close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
+        bytesRead: number;
+        path: string | Buffer;
+        pending: boolean;
+        addListener<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof ReadStreamEventMap>(eventName: E, ...args: ReadStreamEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof ReadStreamEventMap>(eventName: E, listener?: (...args: ReadStreamEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof ReadStreamEventMap>(eventName: E): ((...args: ReadStreamEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof ReadStreamEventMap>(eventName: E): ((...args: ReadStreamEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof ReadStreamEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof ReadStreamEventMap>(eventName: E, listener: (...args: ReadStreamEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    interface Utf8StreamOptions {
+        append?: boolean | undefined;
+        contentMode?: "utf8" | "buffer" | undefined;
+        dest?: string | undefined;
+        fd?: number | undefined;
+        fs?: object | undefined;
+        fsync?: boolean | undefined;
+        maxLength?: number | undefined;
+        maxWrite?: number | undefined;
+        minLength?: number | undefined;
+        mkdir?: boolean | undefined;
+        mode?: number | string | undefined;
+        periodicFlush?: number | undefined;
+        retryEAGAIN?: ((err: Error | null, writeBufferLen: number, remainingBufferLen: number) => boolean) | undefined;
+        sync?: boolean | undefined;
+    }
+    interface Utf8StreamEventMap {
+        "close": [
+        ];
+        "drain": [
+        ];
+        "drop": [
+            data: string | Buffer
+        ];
+        "error": [
+            error: Error
+        ];
+        "finish": [
+        ];
+        "ready": [
+        ];
+        "write": [
+            n: number
+        ];
+    }
+    class Utf8Stream implements EventEmitter {
+        constructor(options: Utf8StreamOptions);
+        readonly append: boolean;
+        readonly contentMode: "utf8" | "buffer";
+        destroy(): void;
+        end(): void;
+        readonly fd: number;
+        readonly file: string;
+        flush(callback: (err: Error | null) => void): void;
+        flushSync(): void;
+        readonly fsync: boolean;
+        readonly maxLength: number;
+        readonly minLength: number;
+        readonly mkdir: boolean;
+        readonly mode: number | string;
+        readonly periodicFlush: number;
+        reopen(file: PathLike): void;
+        readonly sync: boolean;
+        write(data: string | Buffer): boolean;
+        readonly writing: boolean;
+        [Symbol.dispose](): void;
+    }
+    interface Utf8Stream extends InternalEventEmitter<Utf8StreamEventMap> {
+    }
+    interface WriteStreamEventMap extends stream.WritableEventMap {
+        "close": [
+        ];
+        "open": [
+            fd: number
+        ];
+        "ready": [
+        ];
+    }
+    class WriteStream extends stream.Writable {
+        close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
+        bytesWritten: number;
+        path: string | Buffer;
+        pending: boolean;
+        addListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        emit<E extends keyof WriteStreamEventMap>(eventName: E, ...args: WriteStreamEventMap[E]): boolean;
+        emit(eventName: string | symbol, ...args: any[]): boolean;
+        listenerCount<E extends keyof WriteStreamEventMap>(eventName: E, listener?: (...args: WriteStreamEventMap[E]) => void): number;
+        listenerCount(eventName: string | symbol, listener?: (...args: any[]) => void): number;
+        listeners<E extends keyof WriteStreamEventMap>(eventName: E): ((...args: WriteStreamEventMap[E]) => void)[];
+        listeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        off<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        on<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        once<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        prependOnceListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+        rawListeners<E extends keyof WriteStreamEventMap>(eventName: E): ((...args: WriteStreamEventMap[E]) => void)[];
+        rawListeners(eventName: string | symbol): ((...args: any[]) => void)[];
+        removeAllListeners<E extends keyof WriteStreamEventMap>(eventName?: E): this;
+        removeAllListeners(eventName?: string | symbol): this;
+        removeListener<E extends keyof WriteStreamEventMap>(eventName: E, listener: (...args: WriteStreamEventMap[E]) => void): this;
+        removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+    }
+    function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
+    namespace rename {
+        function __promisify__(oldPath: PathLike, newPath: PathLike): Promise<void>;
+    }
+    function renameSync(oldPath: PathLike, newPath: PathLike): void;
+    function truncate(path: PathLike, len: number | undefined, callback: NoParamCallback): void;
+    function truncate(path: PathLike, callback: NoParamCallback): void;
+    namespace truncate {
+        function __promisify__(path: PathLike, len?: number): Promise<void>;
+    }
+    function truncateSync(path: PathLike, len?: number): void;
+    function ftruncate(fd: number, len: number | undefined, callback: NoParamCallback): void;
+    function ftruncate(fd: number, callback: NoParamCallback): void;
+    namespace ftruncate {
+        function __promisify__(fd: number, len?: number): Promise<void>;
+    }
+    function ftruncateSync(fd: number, len?: number): void;
+    function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
+    namespace chown {
+        function __promisify__(path: PathLike, uid: number, gid: number): Promise<void>;
+    }
+    function chownSync(path: PathLike, uid: number, gid: number): void;
+    function fchown(fd: number, uid: number, gid: number, callback: NoParamCallback): void;
+    namespace fchown {
+        function __promisify__(fd: number, uid: number, gid: number): Promise<void>;
+    }
+    function fchownSync(fd: number, uid: number, gid: number): void;
+    function lchown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
+    namespace lchown {
+        function __promisify__(path: PathLike, uid: number, gid: number): Promise<void>;
+    }
+    function lchownSync(path: PathLike, uid: number, gid: number): void;
+    function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    namespace lutimes {
+        function __promisify__(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
+    }
+    function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+    function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
+    namespace chmod {
+        function __promisify__(path: PathLike, mode: Mode): Promise<void>;
+    }
+    function chmodSync(path: PathLike, mode: Mode): void;
+    function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void;
+    namespace fchmod {
+        function __promisify__(fd: number, mode: Mode): Promise<void>;
+    }
+    function fchmodSync(fd: number, mode: Mode): void;
+    function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
+    namespace lchmod {
+        function __promisify__(path: PathLike, mode: Mode): Promise<void>;
+    }
+    function lchmodSync(path: PathLike, mode: Mode): void;
+    function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function stat(path: PathLike, options: (StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry?: true | undefined;
+    }) | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function stat(path: PathLike, options: StatOptions & {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void): void;
+    function stat(path: PathLike, options: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: Stats | undefined) => void): void;
+    function stat(path: PathLike, options: StatOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats | undefined) => void): void;
+    function stat(path: PathLike, options: StatOptions & {
+        throwIfNoEntry?: true | undefined;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+    function stat(path: PathLike, options: StatOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats | undefined) => void): void;
+    namespace stat {
+        function __promisify__(path: PathLike): Promise<Stats>;
+        function __promisify__(path: PathLike, options?: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry?: true | undefined;
+        }): Promise<Stats>;
+        function __promisify__(path: PathLike, options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry?: true | undefined;
+        }): Promise<BigIntStats>;
+        function __promisify__(path: PathLike, options: StatOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        }): Promise<Stats | undefined>;
+        function __promisify__(path: PathLike, options: StatOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        }): Promise<BigIntStats | undefined>;
+        function __promisify__(path: PathLike, options: StatOptions & {
+            throwIfNoEntry?: true | undefined;
+        }): Promise<Stats | BigIntStats>;
+        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats | undefined>;
+    }
+    interface StatSyncFn extends Function {
+        (path: PathLike, options?: undefined): Stats;
+        (path: PathLike, options?: StatSyncOptions & {
+            bigint?: false | undefined;
+            throwIfNoEntry: false;
+        }): Stats | undefined;
+        (path: PathLike, options: StatSyncOptions & {
+            bigint: true;
+            throwIfNoEntry: false;
+        }): BigIntStats | undefined;
+        (path: PathLike, options?: StatSyncOptions & {
+            bigint?: false | undefined;
+        }): Stats;
+        (path: PathLike, options: StatSyncOptions & {
+            bigint: true;
+        }): BigIntStats;
+        (path: PathLike, options: StatSyncOptions & {
+            bigint: boolean;
+            throwIfNoEntry?: false | undefined;
+        }): Stats | BigIntStats;
+        (path: PathLike, options?: StatSyncOptions): Stats | BigIntStats | undefined;
+    }
+    function statSync(path: PathLike): Stats;
+    function statSync(path: PathLike, options?: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry?: true | undefined;
+    }): Stats;
+    function statSync(path: PathLike, options: StatOptions & {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }): BigIntStats;
+    function statSync(path: PathLike, options: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Stats | undefined;
+    function statSync(path: PathLike, options: StatOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): BigIntStats | undefined;
+    function statSync(path: PathLike, options: StatOptions & {
+        throwIfNoEntry?: true | undefined;
+    }): Stats | BigIntStats;
+    function statSync(path: PathLike, options?: StatOptions): Stats | BigIntStats | undefined;
+    function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function fstat(fd: number, options: (StatOptions & {
+        bigint?: false | undefined;
+    }) | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function fstat(fd: number, options: StatOptions & {
+        bigint: true;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void): void;
+    function fstat(fd: number, options: StatOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+    namespace fstat {
+        function __promisify__(fd: number, options?: StatOptions & {
+            bigint?: false | undefined;
+        }): Promise<Stats>;
+        function __promisify__(fd: number, options: StatOptions & {
+            bigint: true;
+        }): Promise<BigIntStats>;
+        function __promisify__(fd: number, options?: StatOptions): Promise<Stats | BigIntStats>;
+    }
+    function fstatSync(fd: number, options?: StatOptions & {
+        bigint?: false | undefined;
+    }): Stats;
+    function fstatSync(fd: number, options: StatOptions & {
+        bigint: true;
+    }): BigIntStats;
+    function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
+    function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function lstat(path: PathLike, options: (StatOptions & {
+        bigint?: false | undefined;
+    }) | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function lstat(path: PathLike, options: StatOptions & {
+        bigint: true;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void): void;
+    function lstat(path: PathLike, options: StatOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void): void;
+    namespace lstat {
+        function __promisify__(path: PathLike, options?: StatOptions & {
+            bigint?: false | undefined;
+        }): Promise<Stats>;
+        function __promisify__(path: PathLike, options: StatOptions & {
+            bigint: true;
+        }): Promise<BigIntStats>;
+        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
+    }
+    function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
+    function statfs(path: PathLike, options: (StatFsOptions & {
+        bigint?: false | undefined;
+    }) | undefined, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
+    function statfs(path: PathLike, options: StatFsOptions & {
+        bigint: true;
+    }, callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatsFs) => void): void;
+    function statfs(path: PathLike, options: StatFsOptions | undefined, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs | BigIntStatsFs) => void): void;
+    namespace statfs {
+        function __promisify__(path: PathLike, options?: StatFsOptions & {
+            bigint?: false | undefined;
+        }): Promise<StatsFs>;
+        function __promisify__(path: PathLike, options: StatFsOptions & {
+            bigint: true;
+        }): Promise<BigIntStatsFs>;
+        function __promisify__(path: PathLike, options?: StatFsOptions): Promise<StatsFs | BigIntStatsFs>;
+    }
+    function statfsSync(path: PathLike, options?: StatFsOptions & {
+        bigint?: false | undefined;
+    }): StatsFs;
+    function statfsSync(path: PathLike, options: StatFsOptions & {
+        bigint: true;
+    }): BigIntStatsFs;
+    function statfsSync(path: PathLike, options?: StatFsOptions): StatsFs | BigIntStatsFs;
+    function lstatSync(path: PathLike): Stats;
+    function lstatSync(path: PathLike, options?: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry?: true | undefined;
+    }): Stats;
+    function lstatSync(path: PathLike, options: StatOptions & {
+        bigint: true;
+        throwIfNoEntry?: true | undefined;
+    }): BigIntStats;
+    function lstatSync(path: PathLike, options: StatOptions & {
+        bigint?: false | undefined;
+        throwIfNoEntry: false;
+    }): Stats | undefined;
+    function lstatSync(path: PathLike, options: StatOptions & {
+        bigint: true;
+        throwIfNoEntry: false;
+    }): BigIntStats | undefined;
+    function lstatSync(path: PathLike, options: StatOptions & {
+        throwIfNoEntry?: true | undefined;
+    }): Stats | BigIntStats;
+    function lstatSync(path: PathLike, options?: StatOptions): Stats | BigIntStats | undefined;
+    function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
+    namespace link {
+        function __promisify__(existingPath: PathLike, newPath: PathLike): Promise<void>;
+    }
+    function linkSync(existingPath: PathLike, newPath: PathLike): void;
+    function symlink(target: PathLike, path: PathLike, type: symlink.Type | undefined | null, callback: NoParamCallback): void;
+    function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
+    namespace symlink {
+        function __promisify__(target: PathLike, path: PathLike, type?: string | null): Promise<void>;
+        type Type = "dir" | "file" | "junction";
+    }
+    function symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type | null): void;
+    function readlink(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, linkString: string) => void): void;
+    function readlink(path: PathLike, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, linkString: NonSharedBuffer) => void): void;
+    function readlink(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, linkString: string | NonSharedBuffer) => void): void;
+    function readlink(path: PathLike, callback: (err: NodeJS.ErrnoException | null, linkString: string) => void): void;
+    namespace readlink {
+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string>;
+        function __promisify__(path: PathLike, options: BufferEncodingOption): Promise<NonSharedBuffer>;
+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string | NonSharedBuffer>;
+    }
+    function readlinkSync(path: PathLike, options?: EncodingOption): string;
+    function readlinkSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+    function readlinkSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    function realpath(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
+    function realpath(path: PathLike, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: NonSharedBuffer) => void): void;
+    function realpath(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string | NonSharedBuffer) => void): void;
+    function realpath(path: PathLike, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
+    namespace realpath {
+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string>;
+        function __promisify__(path: PathLike, options: BufferEncodingOption): Promise<NonSharedBuffer>;
+        function __promisify__(path: PathLike, options?: EncodingOption): Promise<string | NonSharedBuffer>;
+        function native(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
+        function native(path: PathLike, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: NonSharedBuffer) => void): void;
+        function native(path: PathLike, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string | NonSharedBuffer) => void): void;
+        function native(path: PathLike, callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void): void;
+    }
+    function realpathSync(path: PathLike, options?: EncodingOption): string;
+    function realpathSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+    function realpathSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    namespace realpathSync {
+        function native(path: PathLike, options?: EncodingOption): string;
+        function native(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+        function native(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    }
+    function unlink(path: PathLike, callback: NoParamCallback): void;
+    namespace unlink {
+        function __promisify__(path: PathLike): Promise<void>;
+    }
+    function unlinkSync(path: PathLike): void;
+    interface RmDirOptions {
+    }
+    function rmdir(path: PathLike, callback: NoParamCallback): void;
+    namespace rmdir {
+        function __promisify__(path: PathLike): Promise<void>;
+    }
+    function rmdirSync(path: PathLike): void;
+    interface RmOptions {
+        force?: boolean | undefined;
+        maxRetries?: number | undefined;
+        recursive?: boolean | undefined;
+        retryDelay?: number | undefined;
+    }
+    function rm(path: PathLike, callback: NoParamCallback): void;
+    function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
+    namespace rm {
+        function __promisify__(path: PathLike, options?: RmOptions): Promise<void>;
+    }
+    function rmSync(path: PathLike, options?: RmOptions): void;
+    interface MakeDirectoryOptions {
+        recursive?: boolean | undefined;
+        mode?: Mode | undefined;
+    }
+    function mkdir(path: PathLike, options: MakeDirectoryOptions & {
+        recursive: true;
+    }, callback: (err: NodeJS.ErrnoException | null, path?: string) => void): void;
+    function mkdir(path: PathLike, options: Mode | (MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null | undefined, callback: NoParamCallback): void;
+    function mkdir(path: PathLike, options: Mode | MakeDirectoryOptions | null | undefined, callback: (err: NodeJS.ErrnoException | null, path?: string) => void): void;
+    function mkdir(path: PathLike, callback: NoParamCallback): void;
+    namespace mkdir {
+        function __promisify__(path: PathLike, options: MakeDirectoryOptions & {
+            recursive: true;
+        }): Promise<string | undefined>;
+        function __promisify__(path: PathLike, options?: Mode | (MakeDirectoryOptions & {
+            recursive?: false | undefined;
+        }) | null): Promise<void>;
+        function __promisify__(path: PathLike, options?: Mode | MakeDirectoryOptions | null): Promise<string | undefined>;
+    }
+    function mkdirSync(path: PathLike, options: MakeDirectoryOptions & {
+        recursive: true;
+    }): string | undefined;
+    function mkdirSync(path: PathLike, options?: Mode | (MakeDirectoryOptions & {
+        recursive?: false | undefined;
+    }) | null): void;
+    function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined;
+    function mkdtemp(prefix: string, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, folder: string) => void): void;
+    function mkdtemp(prefix: string, options: BufferEncodingOption, callback: (err: NodeJS.ErrnoException | null, folder: NonSharedBuffer) => void): void;
+    function mkdtemp(prefix: string, options: EncodingOption, callback: (err: NodeJS.ErrnoException | null, folder: string | NonSharedBuffer) => void): void;
+    function mkdtemp(prefix: string, callback: (err: NodeJS.ErrnoException | null, folder: string) => void): void;
+    namespace mkdtemp {
+        function __promisify__(prefix: string, options?: EncodingOption): Promise<string>;
+        function __promisify__(prefix: string, options: BufferEncodingOption): Promise<NonSharedBuffer>;
+        function __promisify__(prefix: string, options?: EncodingOption): Promise<string | NonSharedBuffer>;
+    }
+    function mkdtempSync(prefix: string, options?: EncodingOption): string;
+    function mkdtempSync(prefix: string, options: BufferEncodingOption): NonSharedBuffer;
+    function mkdtempSync(prefix: string, options?: EncodingOption): string | NonSharedBuffer;
+    interface DisposableTempDir extends Disposable {
+        path: string;
+        remove(): void;
+        [Symbol.dispose](): void;
+    }
+    function mkdtempDisposableSync(prefix: string, options?: EncodingOption): DisposableTempDir;
+    function readdir(path: PathLike, options: {
+        encoding: BufferEncoding | null;
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    } | BufferEncoding | undefined | null, callback: (err: NodeJS.ErrnoException | null, files: string[]) => void): void;
+    function readdir(path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    } | "buffer", callback: (err: NodeJS.ErrnoException | null, files: NonSharedBuffer[]) => void): void;
+    function readdir(path: PathLike, options: (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | BufferEncoding | undefined | null, callback: (err: NodeJS.ErrnoException | null, files: string[] | NonSharedBuffer[]) => void): void;
+    function readdir(path: PathLike, callback: (err: NodeJS.ErrnoException | null, files: string[]) => void): void;
+    function readdir(path: PathLike, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }, callback: (err: NodeJS.ErrnoException | null, files: Dirent[]) => void): void;
+    function readdir(path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }, callback: (err: NodeJS.ErrnoException | null, files: Dirent<NonSharedBuffer>[]) => void): void;
+    namespace readdir {
+        function __promisify__(path: PathLike, options?: {
+            encoding: BufferEncoding | null;
+            withFileTypes?: false | undefined;
+            recursive?: boolean | undefined;
+        } | BufferEncoding | null): Promise<string[]>;
+        function __promisify__(path: PathLike, options: "buffer" | {
+            encoding: "buffer";
+            withFileTypes?: false | undefined;
+            recursive?: boolean | undefined;
+        }): Promise<NonSharedBuffer[]>;
+        function __promisify__(path: PathLike, options?: (ObjectEncodingOptions & {
+            withFileTypes?: false | undefined;
+            recursive?: boolean | undefined;
+        }) | BufferEncoding | null): Promise<string[] | NonSharedBuffer[]>;
+        function __promisify__(path: PathLike, options: ObjectEncodingOptions & {
+            withFileTypes: true;
+            recursive?: boolean | undefined;
+        }): Promise<Dirent[]>;
+        function __promisify__(path: PathLike, options: {
+            encoding: "buffer";
+            withFileTypes: true;
+            recursive?: boolean | undefined;
+        }): Promise<Dirent<NonSharedBuffer>[]>;
+    }
+    function readdirSync(path: PathLike, options?: {
+        encoding: BufferEncoding | null;
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    } | BufferEncoding | null): string[];
+    function readdirSync(path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    } | "buffer"): NonSharedBuffer[];
+    function readdirSync(path: PathLike, options?: (ObjectEncodingOptions & {
+        withFileTypes?: false | undefined;
+        recursive?: boolean | undefined;
+    }) | BufferEncoding | null): string[] | NonSharedBuffer[];
+    function readdirSync(path: PathLike, options: ObjectEncodingOptions & {
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Dirent[];
+    function readdirSync(path: PathLike, options: {
+        encoding: "buffer";
+        withFileTypes: true;
+        recursive?: boolean | undefined;
+    }): Dirent<NonSharedBuffer>[];
+    function close(fd: number, callback?: NoParamCallback): void;
+    namespace close {
+        function __promisify__(fd: number): Promise<void>;
+    }
+    function closeSync(fd: number): void;
+    function open(path: PathLike, flags: OpenMode | undefined, mode: Mode | undefined | null, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    function open(path: PathLike, flags: OpenMode | undefined, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    namespace open {
+        function __promisify__(path: PathLike, flags: OpenMode, mode?: Mode | null): Promise<number>;
+    }
+    function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
+    function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    namespace utimes {
+        function __promisify__(path: PathLike, atime: TimeLike, mtime: TimeLike): Promise<void>;
+    }
+    function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+    function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    namespace futimes {
+        function __promisify__(fd: number, atime: TimeLike, mtime: TimeLike): Promise<void>;
+    }
+    function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void;
+    function fsync(fd: number, callback: NoParamCallback): void;
+    namespace fsync {
+        function __promisify__(fd: number): Promise<void>;
+    }
+    function fsyncSync(fd: number): void;
+    interface WriteOptions {
+        offset?: number | undefined;
+        length?: number | undefined;
+        position?: number | null | undefined;
+    }
+    function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, offset: number | undefined | null, length: number | undefined | null, position: number | undefined | null, callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void): void;
+    function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, offset: number | undefined | null, length: number | undefined | null, callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void): void;
+    function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, offset: number | undefined | null, callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void): void;
+    function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void): void;
+    function write<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, options: WriteOptions, callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void): void;
+    function write(fd: number, string: string, position: number | undefined | null, encoding: BufferEncoding | undefined | null, callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void): void;
+    function write(fd: number, string: string, position: number | undefined | null, callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void): void;
+    function write(fd: number, string: string, callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void): void;
+    namespace write {
+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer?: TBuffer, offset?: number, length?: number, position?: number | null): Promise<{
+            bytesWritten: number;
+            buffer: TBuffer;
+        }>;
+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer?: TBuffer, options?: WriteOptions): Promise<{
+            bytesWritten: number;
+            buffer: TBuffer;
+        }>;
+        function __promisify__(fd: number, string: string, position?: number | null, encoding?: BufferEncoding | null): Promise<{
+            bytesWritten: number;
+            buffer: string;
+        }>;
+    }
+    function writeSync(fd: number, buffer: NodeJS.ArrayBufferView, offset?: number | null, length?: number | null, position?: number | null): number;
+    function writeSync(fd: number, string: string, position?: number | null, encoding?: BufferEncoding | null): number;
+    type ReadPosition = number | bigint;
+    interface ReadOptions {
+        offset?: number | undefined;
+        length?: number | undefined;
+        position?: ReadPosition | null | undefined;
+    }
+    interface ReadOptionsWithBuffer<T extends NodeJS.ArrayBufferView> extends ReadOptions {
+        buffer?: T | undefined;
+    }
+    interface ReadSyncOptions extends ReadOptions {
+    }
+    interface ReadAsyncOptions<T extends NodeJS.ArrayBufferView> extends ReadOptionsWithBuffer<T> {
+    }
+    function read<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, offset: number, length: number, position: ReadPosition | null, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void): void;
+    function read<TBuffer extends NodeJS.ArrayBufferView = NonSharedBuffer>(fd: number, options: ReadOptionsWithBuffer<TBuffer>, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void): void;
+    function read<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, options: ReadOptions, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void): void;
+    function read<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void): void;
+    function read(fd: number, callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: NonSharedBuffer) => void): void;
+    namespace read {
+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView>(fd: number, buffer: TBuffer, offset: number, length: number, position: ReadPosition | null): Promise<{
+            bytesRead: number;
+            buffer: TBuffer;
+        }>;
+        function __promisify__<TBuffer extends NodeJS.ArrayBufferView = NonSharedBuffer>(fd: number, options: ReadOptionsWithBuffer<TBuffer>): Promise<{
+            bytesRead: number;
+            buffer: TBuffer;
+        }>;
+        function __promisify__(fd: number): Promise<{
+            bytesRead: number;
+            buffer: NonSharedBuffer;
+        }>;
+    }
+    function readSync(fd: number, buffer: NodeJS.ArrayBufferView, offset: number, length: number, position: ReadPosition | null): number;
+    function readSync(fd: number, buffer: NodeJS.ArrayBufferView, opts?: ReadOptions): number;
+    function readFile(path: PathOrFileDescriptor, options: ({
+        encoding?: null | undefined;
+        flag?: string | undefined;
+    } & Abortable) | undefined | null, callback: (err: NodeJS.ErrnoException | null, data: NonSharedBuffer) => void): void;
+    function readFile(path: PathOrFileDescriptor, options: ({
+        encoding: BufferEncoding;
+        flag?: string | undefined;
+    } & Abortable) | BufferEncoding, callback: (err: NodeJS.ErrnoException | null, data: string) => void): void;
+    function readFile(path: PathOrFileDescriptor, options: (ObjectEncodingOptions & {
+        flag?: string | undefined;
+    } & Abortable) | BufferEncoding | undefined | null, callback: (err: NodeJS.ErrnoException | null, data: string | NonSharedBuffer) => void): void;
+    function readFile(path: PathOrFileDescriptor, callback: (err: NodeJS.ErrnoException | null, data: NonSharedBuffer) => void): void;
+    namespace readFile {
+        function __promisify__(path: PathOrFileDescriptor, options?: {
+            encoding?: null | undefined;
+            flag?: string | undefined;
+        } | null): Promise<NonSharedBuffer>;
+        function __promisify__(path: PathOrFileDescriptor, options: {
+            encoding: BufferEncoding;
+            flag?: string | undefined;
+        } | BufferEncoding): Promise<string>;
+        function __promisify__(path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & {
+            flag?: string | undefined;
+        }) | BufferEncoding | null): Promise<string | NonSharedBuffer>;
+    }
+    function readFileSync(path: PathOrFileDescriptor, options?: {
+        encoding?: null | undefined;
+        flag?: string | undefined;
+    } | null): NonSharedBuffer;
+    function readFileSync(path: PathOrFileDescriptor, options: {
+        encoding: BufferEncoding;
+        flag?: string | undefined;
+    } | BufferEncoding): string;
+    function readFileSync(path: PathOrFileDescriptor, options?: (ObjectEncodingOptions & {
+        flag?: string | undefined;
+    }) | BufferEncoding | null): string | NonSharedBuffer;
+    type WriteFileOptions = (ObjectEncodingOptions & Abortable & {
+        mode?: Mode | undefined;
+        flag?: string | undefined;
+        flush?: boolean | undefined;
+    }) | BufferEncoding | null;
+    function writeFile(file: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options: WriteFileOptions, callback: NoParamCallback): void;
+    function writeFile(path: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, callback: NoParamCallback): void;
+    namespace writeFile {
+        function __promisify__(path: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): Promise<void>;
+    }
+    function writeFileSync(file: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, options?: WriteFileOptions): void;
+    function appendFile(path: PathOrFileDescriptor, data: string | Uint8Array, options: WriteFileOptions, callback: NoParamCallback): void;
+    function appendFile(file: PathOrFileDescriptor, data: string | Uint8Array, callback: NoParamCallback): void;
+    namespace appendFile {
+        function __promisify__(file: PathOrFileDescriptor, data: string | Uint8Array, options?: WriteFileOptions): Promise<void>;
+    }
+    function appendFileSync(path: PathOrFileDescriptor, data: string | Uint8Array, options?: WriteFileOptions): void;
+    interface WatchFileOptions {
+        bigint?: boolean | undefined;
+        persistent?: boolean | undefined;
+        interval?: number | undefined;
+    }
+    function watchFile(filename: PathLike, options: (WatchFileOptions & {
+        bigint?: false | undefined;
+    }) | undefined, listener: StatsListener): StatWatcher;
+    function watchFile(filename: PathLike, options: (WatchFileOptions & {
+        bigint: true;
+    }) | undefined, listener: BigIntStatsListener): StatWatcher;
+    function watchFile(filename: PathLike, listener: StatsListener): StatWatcher;
+    function unwatchFile(filename: PathLike, listener?: StatsListener): void;
+    function unwatchFile(filename: PathLike, listener?: BigIntStatsListener): void;
+    type WatchIgnorePredicate = string | RegExp | ((filename: string) => boolean);
+    interface WatchOptions extends Abortable {
+        encoding?: BufferEncoding | "buffer" | undefined;
+        persistent?: boolean | undefined;
+        recursive?: boolean | undefined;
+        ignore?: WatchIgnorePredicate | readonly WatchIgnorePredicate[] | undefined;
+    }
+    interface WatchOptionsWithBufferEncoding extends WatchOptions {
+        encoding: "buffer";
+    }
+    interface WatchOptionsWithStringEncoding extends WatchOptions {
+        encoding?: BufferEncoding | undefined;
+    }
+    type WatchEventType = "rename" | "change";
+    type WatchListener<T> = (event: WatchEventType, filename: T | null) => void;
+    type StatsListener = (curr: Stats, prev: Stats) => void;
+    type BigIntStatsListener = (curr: BigIntStats, prev: BigIntStats) => void;
+    function watch(filename: PathLike, options?: WatchOptionsWithStringEncoding | BufferEncoding | null, listener?: WatchListener<string>): FSWatcher;
+    function watch(filename: PathLike, options: WatchOptionsWithBufferEncoding | "buffer", listener: WatchListener<NonSharedBuffer>): FSWatcher;
+    function watch(filename: PathLike, options: WatchOptions | BufferEncoding | "buffer" | null, listener: WatchListener<string | NonSharedBuffer>): FSWatcher;
+    function watch(filename: PathLike, listener: WatchListener<string>): FSWatcher;
+    function exists(path: PathLike, callback: (exists: boolean) => void): void;
+    namespace exists {
+        function __promisify__(path: PathLike): Promise<boolean>;
+    }
+    function existsSync(path: PathLike): boolean;
+    namespace constants {
+        const F_OK: number;
+        const R_OK: number;
+        const W_OK: number;
+        const X_OK: number;
+        const COPYFILE_EXCL: number;
+        const COPYFILE_FICLONE: number;
+        const COPYFILE_FICLONE_FORCE: number;
+        const O_RDONLY: number;
+        const O_WRONLY: number;
+        const O_RDWR: number;
+        const O_CREAT: number;
+        const O_EXCL: number;
+        const O_NOCTTY: number;
+        const O_TRUNC: number;
+        const O_APPEND: number;
+        const O_DIRECTORY: number;
+        const O_NOATIME: number;
+        const O_NOFOLLOW: number;
+        const O_SYNC: number;
+        const O_DSYNC: number;
+        const O_SYMLINK: number;
+        const O_DIRECT: number;
+        const O_NONBLOCK: number;
+        const S_IFMT: number;
+        const S_IFREG: number;
+        const S_IFDIR: number;
+        const S_IFCHR: number;
+        const S_IFBLK: number;
+        const S_IFIFO: number;
+        const S_IFLNK: number;
+        const S_IFSOCK: number;
+        const S_IRWXU: number;
+        const S_IRUSR: number;
+        const S_IWUSR: number;
+        const S_IXUSR: number;
+        const S_IRWXG: number;
+        const S_IRGRP: number;
+        const S_IWGRP: number;
+        const S_IXGRP: number;
+        const S_IRWXO: number;
+        const S_IROTH: number;
+        const S_IWOTH: number;
+        const S_IXOTH: number;
+        const UV_FS_O_FILEMAP: number;
+    }
+    function access(path: PathLike, mode: number | undefined, callback: NoParamCallback): void;
+    function access(path: PathLike, callback: NoParamCallback): void;
+    namespace access {
+        function __promisify__(path: PathLike, mode?: number): Promise<void>;
+    }
+    function accessSync(path: PathLike, mode?: number): void;
+    interface StreamOptions {
+        flags?: string | undefined;
+        encoding?: BufferEncoding | undefined;
+        fd?: number | FileHandle | undefined;
+        mode?: number | undefined;
+        autoClose?: boolean | undefined;
+        emitClose?: boolean | undefined;
+        start?: number | undefined;
+        signal?: AbortSignal | null | undefined;
+        highWaterMark?: number | undefined;
+    }
+    interface FSImplementation {
+        open?: (...args: any[]) => any;
+        close?: (...args: any[]) => any;
+    }
+    interface CreateReadStreamFSImplementation extends FSImplementation {
+        read: (...args: any[]) => any;
+    }
+    interface CreateWriteStreamFSImplementation extends FSImplementation {
+        write: (...args: any[]) => any;
+        writev?: (...args: any[]) => any;
+    }
+    interface ReadStreamOptions extends StreamOptions {
+        fs?: CreateReadStreamFSImplementation | null | undefined;
+        end?: number | undefined;
+    }
+    interface WriteStreamOptions extends StreamOptions {
+        fs?: CreateWriteStreamFSImplementation | null | undefined;
+        flush?: boolean | undefined;
+    }
+    function createReadStream(path: PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
+    function createWriteStream(path: PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
+    function fdatasync(fd: number, callback: NoParamCallback): void;
+    namespace fdatasync {
+        function __promisify__(fd: number): Promise<void>;
+    }
+    function fdatasyncSync(fd: number): void;
+    function copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
+    function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
+    namespace copyFile {
+        function __promisify__(src: PathLike, dst: PathLike, mode?: number): Promise<void>;
+    }
+    function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
+    function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(fd: number, buffers: TBuffers, cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: TBuffers) => void): void;
+    function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(fd: number, buffers: TBuffers, position: number | null, cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: TBuffers) => void): void;
+    interface WriteVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
+        bytesWritten: number;
+        buffers: T;
+    }
+    namespace writev {
+        function __promisify__<TBuffers extends readonly NodeJS.ArrayBufferView[]>(fd: number, buffers: TBuffers, position?: number): Promise<WriteVResult<TBuffers>>;
+    }
+    function writevSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
+    function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(fd: number, buffers: TBuffers, cb: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: TBuffers) => void): void;
+    function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(fd: number, buffers: TBuffers, position: number | null, cb: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: TBuffers) => void): void;
+    interface ReadVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
+        bytesRead: number;
+        buffers: T;
+    }
+    namespace readv {
+        function __promisify__<TBuffers extends readonly NodeJS.ArrayBufferView[]>(fd: number, buffers: TBuffers, position?: number): Promise<ReadVResult<TBuffers>>;
+    }
+    function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
+    interface OpenAsBlobOptions {
+        type?: string | undefined;
+    }
+    function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
+    interface OpenDirOptions {
+        encoding?: BufferEncoding | undefined;
+        bufferSize?: number | undefined;
+        recursive?: boolean | undefined;
+    }
+    function opendirSync(path: PathLike, options?: OpenDirOptions): Dir;
+    function opendir(path: PathLike, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
+    function opendir(path: PathLike, options: OpenDirOptions, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
+    namespace opendir {
+        function __promisify__(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
+    }
+    interface BigIntStats extends StatsBase<bigint> {
+        atimeNs: bigint;
+        mtimeNs: bigint;
+        ctimeNs: bigint;
+        birthtimeNs: bigint;
+    }
+    interface BigIntOptions {
+        bigint: true;
+    }
+    interface StatOptions {
+        bigint?: boolean | undefined;
+        throwIfNoEntry?: boolean | undefined;
+    }
+    interface StatSyncOptions extends StatOptions {
+    }
+    interface CopyOptionsBase {
+        dereference?: boolean | undefined;
+        errorOnExist?: boolean | undefined;
+        force?: boolean | undefined;
+        mode?: number | undefined;
+        preserveTimestamps?: boolean | undefined;
+        recursive?: boolean | undefined;
+        verbatimSymlinks?: boolean | undefined;
+    }
+    interface CopyOptions extends CopyOptionsBase {
+        filter?: ((source: string, destination: string) => boolean | Promise<boolean>) | undefined;
+    }
+    interface CopySyncOptions extends CopyOptionsBase {
+        filter?: ((source: string, destination: string) => boolean) | undefined;
+    }
+    function cp(source: string | URL, destination: string | URL, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    function cp(source: string | URL, destination: string | URL, opts: CopyOptions, callback: (err: NodeJS.ErrnoException | null) => void): void;
+    function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
+    interface _GlobOptions<T extends Dirent | string> {
+        cwd?: string | URL | undefined;
+        withFileTypes?: boolean | undefined;
+        exclude?: ((fileName: T) => boolean) | readonly string[] | undefined;
+    }
+    interface GlobOptions extends _GlobOptions<Dirent | string> {
+    }
+    interface GlobOptionsWithFileTypes extends _GlobOptions<Dirent> {
+        withFileTypes: true;
+    }
+    interface GlobOptionsWithoutFileTypes extends _GlobOptions<string> {
+        withFileTypes?: false | undefined;
+    }
+    function glob(pattern: string | readonly string[], callback: (err: NodeJS.ErrnoException | null, matches: string[]) => void): void;
+    function glob(pattern: string | readonly string[], options: GlobOptionsWithFileTypes, callback: (err: NodeJS.ErrnoException | null, matches: Dirent[]) => void): void;
+    function glob(pattern: string | readonly string[], options: GlobOptionsWithoutFileTypes, callback: (err: NodeJS.ErrnoException | null, matches: string[]) => void): void;
+    function glob(pattern: string | readonly string[], options: GlobOptions, callback: (err: NodeJS.ErrnoException | null, matches: Dirent[] | string[]) => void): void;
+    function globSync(pattern: string | readonly string[]): string[];
+    function globSync(pattern: string | readonly string[], options: GlobOptionsWithFileTypes): Dirent[];
+    function globSync(pattern: string | readonly string[], options: GlobOptionsWithoutFileTypes): string[];
+    function globSync(pattern: string | readonly string[], options: GlobOptions): Dirent[] | string[];
+}
+declare module "node:fs" {
+    export * as promises from "node:fs/promises";
+}
+declare module "fs" {
+    export * from "node:fs";
+}