@secure-exec/nodejs 0.2.0-rc.1

package/dist/bridge/dispatch.js

@@ -0,0 +1,40 @@
+function encodeDispatchArgs(args) {
+    return JSON.stringify(args, (_key, value) => value === undefined ? { __secureExecDispatchType: "undefined" } : value);
+}
+function encodeDispatch(method, args) {
+    return `__bd:${method}:${encodeDispatchArgs(args)}`;
+}
+function parseDispatchResult(resultJson) {
+    if (resultJson === null) {
+        return undefined;
+    }
+    const parsed = JSON.parse(resultJson);
+    if (parsed.__bd_error) {
+        const error = new Error(parsed.__bd_error.message);
+        error.name = parsed.__bd_error.name ?? "Error";
+        if (parsed.__bd_error.code !== undefined) {
+            error.code = parsed.__bd_error.code;
+        }
+        if (parsed.__bd_error.stack) {
+            error.stack = parsed.__bd_error.stack;
+        }
+        throw error;
+    }
+    return parsed.__bd_result;
+}
+function requireDispatchBridge() {
+    if (!_loadPolyfill) {
+        throw new Error("_loadPolyfill is not available in sandbox");
+    }
+    return _loadPolyfill;
+}
+export function bridgeDispatchSync(method, ...args) {
+    const bridge = requireDispatchBridge();
+    return parseDispatchResult(bridge.applySyncPromise(undefined, [encodeDispatch(method, args)]));
+}
+export async function bridgeDispatchAsync(method, ...args) {
+    const bridge = requireDispatchBridge();
+    return parseDispatchResult(await bridge.apply(undefined, [encodeDispatch(method, args)], {
+        result: { promise: true },
+    }));
+}

package/dist/bridge/fs.d.ts

@@ -0,0 +1,502 @@
+import { Buffer } from "buffer";
+import type * as nodeFs from "fs";
+declare class Stats implements nodeFs.Stats {
+    dev: number;
+    ino: number;
+    mode: number;
+    nlink: number;
+    uid: number;
+    gid: number;
+    rdev: number;
+    size: number;
+    blksize: number;
+    blocks: number;
+    atimeMs: number;
+    mtimeMs: number;
+    ctimeMs: number;
+    birthtimeMs: number;
+    atime: Date;
+    mtime: Date;
+    ctime: Date;
+    birthtime: Date;
+    constructor(init: {
+        dev?: number;
+        ino?: number;
+        mode: number;
+        nlink?: number;
+        uid?: number;
+        gid?: number;
+        rdev?: number;
+        size: number;
+        blksize?: number;
+        blocks?: number;
+        atimeMs?: number;
+        mtimeMs?: number;
+        ctimeMs?: number;
+        birthtimeMs?: number;
+    });
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+declare class Dirent implements nodeFs.Dirent<string> {
+    name: string;
+    parentPath: string;
+    path: string;
+    private _isDir;
+    constructor(name: string, isDir: boolean, parentPath?: string);
+    isFile(): boolean;
+    isDirectory(): boolean;
+    isSymbolicLink(): boolean;
+    isBlockDevice(): boolean;
+    isCharacterDevice(): boolean;
+    isFIFO(): boolean;
+    isSocket(): boolean;
+}
+declare class Dir {
+    readonly path: string;
+    private _entries;
+    private _index;
+    private _closed;
+    constructor(dirPath: string);
+    private _load;
+    readSync(): Dirent | null;
+    read(): Promise<Dirent | null>;
+    closeSync(): void;
+    close(): Promise<void>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
+}
+type FileHandleReadFileOptions = nodeFs.ObjectEncodingOptions & {
+    signal?: AbortSignal | undefined;
+};
+type FileHandleWriteFileOptions = nodeFs.ObjectEncodingOptions & {
+    signal?: AbortSignal | undefined;
+};
+declare class FileHandle {
+    private _fd;
+    private _closing;
+    private _closed;
+    private _listeners;
+    constructor(fd: number);
+    private static _assertHandle;
+    private _emitCloseOnce;
+    private _resolvePath;
+    get fd(): number;
+    get closed(): boolean;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    close(): Promise<void>;
+    stat(): Promise<Stats>;
+    sync(): Promise<void>;
+    datasync(): Promise<void>;
+    truncate(len?: number): Promise<void>;
+    chmod(mode: Mode): Promise<void>;
+    chown(uid: number, gid: number): Promise<void>;
+    utimes(atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+    read(buffer: NodeJS.ArrayBufferView | null, offset?: number, length?: number, position?: number | null): Promise<{
+        bytesRead: number;
+        buffer: NodeJS.ArrayBufferView;
+    }>;
+    write(buffer: string | NodeJS.ArrayBufferView, offsetOrPosition?: number, lengthOrEncoding?: number | BufferEncoding, position?: number): Promise<{
+        bytesWritten: number;
+        buffer: string | NodeJS.ArrayBufferView;
+    }>;
+    readFile(options?: BufferEncoding | FileHandleReadFileOptions | null): Promise<string | Buffer>;
+    writeFile(data: unknown, options?: BufferEncoding | FileHandleWriteFileOptions | null): Promise<void>;
+    appendFile(data: unknown, options?: BufferEncoding | FileHandleWriteFileOptions | null): Promise<void>;
+    createReadStream(options?: {
+        encoding?: BufferEncoding;
+        start?: number;
+        end?: number;
+        highWaterMark?: number;
+        signal?: AbortSignal;
+    }): ReadStream;
+    createWriteStream(options?: {
+        encoding?: BufferEncoding;
+        flags?: string;
+        mode?: number;
+    }): WriteStream;
+}
+declare class ReadStream {
+    private _options?;
+    bytesRead: number;
+    path: string | Buffer | null;
+    pending: boolean;
+    readable: boolean;
+    readableAborted: boolean;
+    readableDidRead: boolean;
+    readableEncoding: BufferEncoding | null;
+    readableEnded: boolean;
+    readableFlowing: boolean | null;
+    readableHighWaterMark: number;
+    readableLength: number;
+    readableObjectMode: boolean;
+    destroyed: boolean;
+    closed: boolean;
+    errored: Error | null;
+    fd: number | null;
+    autoClose: boolean;
+    start: number | undefined;
+    end: number | undefined;
+    private _listeners;
+    private _started;
+    private _reading;
+    private _readScheduled;
+    private _opening;
+    private _remaining;
+    private _position;
+    private _fileHandle;
+    private _streamFs?;
+    private _signal?;
+    private _handleCloseListener?;
+    constructor(filePath: string | Buffer | null, _options?: {
+        encoding?: BufferEncoding;
+        start?: number;
+        end?: number;
+        highWaterMark?: number;
+        bufferSize?: number;
+        autoClose?: boolean;
+        fd?: number | FileHandle;
+        fs?: unknown;
+        signal?: AbortSignal;
+    } | undefined);
+    private _emitOpen;
+    private _openIfNeeded;
+    private _closeUnderlying;
+    private _scheduleRead;
+    private _readNextChunk;
+    private _finishReadable;
+    private _handleStreamError;
+    private _abort;
+    private _readAllContent;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeAllListeners(event?: string | symbol): this;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    read(): Buffer | string | null;
+    pipe<T extends NodeJS.WritableStream>(destination: T, _options?: {
+        end?: boolean;
+    }): T;
+    unpipe(_destination?: NodeJS.WritableStream): this;
+    pause(): this;
+    resume(): this;
+    setEncoding(encoding: BufferEncoding): this;
+    destroy(error?: Error): this;
+    close(callback?: (err?: Error | null) => void): void;
+    [Symbol.asyncIterator](): AsyncIterator<Buffer | string>;
+}
+declare class WriteStream {
+    private _options?;
+    bytesWritten: number;
+    path: string | Buffer | null;
+    pending: boolean;
+    writable: boolean;
+    writableAborted: boolean;
+    writableEnded: boolean;
+    writableFinished: boolean;
+    writableHighWaterMark: number;
+    writableLength: number;
+    writableObjectMode: boolean;
+    writableCorked: number;
+    destroyed: boolean;
+    closed: boolean;
+    errored: Error | null;
+    writableNeedDrain: boolean;
+    fd: number | null;
+    autoClose: boolean;
+    private _chunks;
+    private _listeners;
+    private _fileHandle;
+    private _streamFs?;
+    constructor(filePath: string | Buffer | null, _options?: {
+        encoding?: BufferEncoding;
+        flags?: string;
+        mode?: number;
+        fd?: number | FileHandle;
+        fs?: unknown;
+        autoClose?: boolean;
+    } | undefined);
+    private _closeUnderlying;
+    close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
+    write(chunk: unknown, encodingOrCallback?: BufferEncoding | ((error: Error | null | undefined) => void), callback?: (error: Error | null | undefined) => void): boolean;
+    end(chunkOrCb?: unknown, encodingOrCallback?: BufferEncoding | (() => void), callback?: () => void): this;
+    setDefaultEncoding(_encoding: BufferEncoding): this;
+    cork(): void;
+    uncork(): void;
+    destroy(error?: Error): this;
+    addListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    on(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    once(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeListener(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    off(event: string | symbol, listener: (...args: unknown[]) => void): this;
+    removeAllListeners(event?: string | symbol): this;
+    emit(event: string | symbol, ...args: unknown[]): boolean;
+    pipe<T extends NodeJS.WritableStream>(destination: T, _options?: {
+        end?: boolean;
+    }): T;
+    unpipe(_destination?: NodeJS.WritableStream): this;
+    [Symbol.asyncDispose](): Promise<void>;
+}
+type PathLike = nodeFs.PathLike;
+type PathOrFileDescriptor = nodeFs.PathOrFileDescriptor;
+type OpenMode = nodeFs.OpenMode;
+type Mode = nodeFs.Mode;
+type ReadFileOptions = Parameters<typeof nodeFs.readFileSync>[1];
+type WriteFileOptions = nodeFs.WriteFileOptions;
+type MakeDirectoryOptions = nodeFs.MakeDirectoryOptions;
+type RmDirOptions = nodeFs.RmDirOptions;
+type ReaddirOptions = nodeFs.ObjectEncodingOptions & {
+    withFileTypes?: boolean;
+    recursive?: boolean;
+};
+type MkdirOptions = MakeDirectoryOptions;
+type OpenFlags = nodeFs.OpenMode;
+type NodeCallback<T> = (err: NodeJS.ErrnoException | null, result?: T) => void;
+declare const fs: {
+    constants: {
+        F_OK: number;
+        R_OK: number;
+        W_OK: number;
+        X_OK: number;
+        COPYFILE_EXCL: number;
+        COPYFILE_FICLONE: number;
+        COPYFILE_FICLONE_FORCE: number;
+        O_RDONLY: number;
+        O_WRONLY: number;
+        O_RDWR: number;
+        O_CREAT: number;
+        O_EXCL: number;
+        O_NOCTTY: number;
+        O_TRUNC: number;
+        O_APPEND: number;
+        O_DIRECTORY: number;
+        O_NOATIME: number;
+        O_NOFOLLOW: number;
+        O_SYNC: number;
+        O_DSYNC: number;
+        O_SYMLINK: number;
+        O_DIRECT: number;
+        O_NONBLOCK: number;
+        S_IFMT: number;
+        S_IFREG: number;
+        S_IFDIR: number;
+        S_IFCHR: number;
+        S_IFBLK: number;
+        S_IFIFO: number;
+        S_IFLNK: number;
+        S_IFSOCK: number;
+        S_IRWXU: number;
+        S_IRUSR: number;
+        S_IWUSR: number;
+        S_IXUSR: number;
+        S_IRWXG: number;
+        S_IRGRP: number;
+        S_IWGRP: number;
+        S_IXGRP: number;
+        S_IRWXO: number;
+        S_IROTH: number;
+        S_IWOTH: number;
+        S_IXOTH: number;
+        UV_FS_O_FILEMAP: number;
+    };
+    Stats: typeof Stats;
+    Dirent: typeof Dirent;
+    Dir: typeof Dir;
+    readFileSync(path: PathOrFileDescriptor, options?: ReadFileOptions): string | Buffer;
+    writeFileSync(file: PathOrFileDescriptor, data: string | NodeJS.ArrayBufferView, _options?: WriteFileOptions): void;
+    appendFileSync(path: PathOrFileDescriptor, data: string | Uint8Array, options?: WriteFileOptions): void;
+    readdirSync(path: PathLike, options?: nodeFs.ObjectEncodingOptions & {
+        withFileTypes?: boolean;
+        recursive?: boolean;
+    }): string[] | Dirent[];
+    mkdirSync(path: PathLike, options?: MakeDirectoryOptions | Mode): string | undefined;
+    rmdirSync(path: PathLike, _options?: RmDirOptions): void;
+    rmSync(path: PathLike, options?: {
+        force?: boolean;
+        recursive?: boolean;
+    }): void;
+    existsSync(path: PathLike): boolean;
+    statSync(path: PathLike, _options?: nodeFs.StatSyncOptions): Stats;
+    lstatSync(path: PathLike, _options?: nodeFs.StatSyncOptions): Stats;
+    unlinkSync(path: PathLike): void;
+    renameSync(oldPath: PathLike, newPath: PathLike): void;
+    copyFileSync(src: PathLike, dest: PathLike, _mode?: number): void;
+    cpSync(src: PathLike, dest: PathLike, options?: {
+        recursive?: boolean;
+        force?: boolean;
+        errorOnExist?: boolean;
+    }): void;
+    mkdtempSync(prefix: string, _options?: nodeFs.EncodingOption): string;
+    opendirSync(path: PathLike, _options?: nodeFs.OpenDirOptions): Dir;
+    openSync(path: PathLike, flags?: OpenMode, _mode?: Mode | null): number;
+    closeSync(fd: number): void;
+    readSync(fd: number, buffer: NodeJS.ArrayBufferView, offset?: number | Record<string, unknown> | null, length?: number | null, position?: nodeFs.ReadPosition | null): number;
+    writeSync(fd: number, buffer: string | NodeJS.ArrayBufferView, offsetOrPosition?: number | Record<string, unknown> | null, lengthOrEncoding?: number | BufferEncoding | null, position?: number | null): number;
+    fstatSync(fd: number): Stats;
+    ftruncateSync(fd: number, len?: number): void;
+    fsyncSync(fd: number): void;
+    fdatasyncSync(fd: number): void;
+    readvSync(fd: number, buffers: ArrayBufferView[], position?: number | null): number;
+    statfsSync(path: PathLike, _options?: nodeFs.StatFsOptions): nodeFs.StatsFs;
+    globSync(pattern: string | string[], _options?: nodeFs.GlobOptionsWithFileTypes): string[];
+    chmodSync(path: PathLike, mode: Mode): void;
+    chownSync(path: PathLike, uid: number, gid: number): void;
+    fchmodSync(fd: number, mode: Mode): void;
+    fchownSync(fd: number, uid: number, gid: number): void;
+    lchownSync(path: PathLike, uid: number, gid: number): void;
+    linkSync(existingPath: PathLike, newPath: PathLike): void;
+    symlinkSync(target: PathLike, path: PathLike, _type?: string | null): void;
+    readlinkSync(path: PathLike, _options?: nodeFs.EncodingOption): string;
+    truncateSync(path: PathLike, len?: number | null): void;
+    utimesSync(path: PathLike, atime: string | number | Date, mtime: string | number | Date): void;
+    readFile(path: string, options?: ReadFileOptions | NodeCallback<string | Uint8Array>, callback?: NodeCallback<string | Uint8Array>): Promise<string | Uint8Array> | void;
+    writeFile(path: string, data: string | Uint8Array, options?: WriteFileOptions | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    appendFile(path: string, data: string | Uint8Array, options?: WriteFileOptions | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    readdir(path: string, options?: ReaddirOptions | NodeCallback<string[] | Dirent[]>, callback?: NodeCallback<string[] | Dirent[]>): Promise<string[] | Dirent[]> | void;
+    mkdir(path: string, options?: MkdirOptions | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    rmdir(path: string, callback?: NodeCallback<void>): Promise<void> | void;
+    rm(path: string, options?: {
+        force?: boolean;
+        recursive?: boolean;
+    } | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    exists(path: string, callback?: (exists: boolean) => void): Promise<boolean> | void;
+    stat(path: string, callback?: NodeCallback<Stats>): Promise<Stats> | void;
+    lstat(path: string, callback?: NodeCallback<Stats>): Promise<Stats> | void;
+    unlink(path: string, callback?: NodeCallback<void>): Promise<void> | void;
+    rename(oldPath: string, newPath: string, callback?: NodeCallback<void>): Promise<void> | void;
+    copyFile(src: string, dest: string, callback?: NodeCallback<void>): Promise<void> | void;
+    cp(src: string, dest: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+        errorOnExist?: boolean;
+    } | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    mkdtemp(prefix: string, options?: nodeFs.EncodingOption | NodeCallback<string>, callback?: NodeCallback<string>): Promise<string> | void;
+    opendir(path: string, options?: nodeFs.OpenDirOptions | NodeCallback<Dir>, callback?: NodeCallback<Dir>): Promise<Dir> | void;
+    open(path: string, flags?: OpenFlags | NodeCallback<number>, mode?: number | NodeCallback<number>, callback?: NodeCallback<number>): Promise<number> | void;
+    close(fd: number, callback?: NodeCallback<void>): Promise<void> | void;
+    read(fd: number, buffer: Uint8Array, offset: number, length: number, position: number | null, callback?: (err: Error | null, bytesRead?: number, buffer?: Uint8Array) => void): Promise<number> | void;
+    write(fd: number, buffer: string | Uint8Array, offset?: number | Record<string, unknown> | NodeCallback<number>, length?: number | BufferEncoding | NodeCallback<number>, position?: number | null | NodeCallback<number>, callback?: NodeCallback<number>): Promise<number> | void;
+    writev(fd: number, buffers: ArrayBufferView[], position?: number | null | ((err: Error | null, bytesWritten?: number, buffers?: ArrayBufferView[]) => void), callback?: (err: Error | null, bytesWritten?: number, buffers?: ArrayBufferView[]) => void): void;
+    writevSync(fd: number, buffers: ArrayBufferView[], position?: number | null): number;
+    fstat(fd: number, callback?: NodeCallback<Stats>): Promise<Stats> | void;
+    fsync(fd: number, callback?: NodeCallback<void>): Promise<void> | void;
+    fdatasync(fd: number, callback?: NodeCallback<void>): Promise<void> | void;
+    readv(fd: number, buffers: ArrayBufferView[], position?: number | null | ((err: Error | null, bytesRead?: number, buffers?: ArrayBufferView[]) => void), callback?: (err: Error | null, bytesRead?: number, buffers?: ArrayBufferView[]) => void): void;
+    statfs(path: PathLike, options?: nodeFs.StatFsOptions | NodeCallback<nodeFs.StatsFs>, callback?: NodeCallback<nodeFs.StatsFs>): Promise<nodeFs.StatsFs> | void;
+    glob(pattern: string | string[], options?: nodeFs.GlobOptionsWithFileTypes | ((err: Error | null, matches?: string[]) => void), callback?: (err: Error | null, matches?: string[]) => void): void;
+    promises: {
+        readFile(path: string | FileHandle, options?: ReadFileOptions | FileHandleReadFileOptions): Promise<string | Buffer<ArrayBufferLike>>;
+        writeFile(path: string | FileHandle, data: unknown, options?: WriteFileOptions | FileHandleWriteFileOptions): Promise<void>;
+        appendFile(path: string | FileHandle, data: unknown, options?: WriteFileOptions | FileHandleWriteFileOptions): Promise<void>;
+        readdir(path: string, options?: ReaddirOptions): Promise<string[] | Dirent[]>;
+        mkdir(path: string, options?: MkdirOptions): Promise<string | undefined>;
+        rmdir(path: string): Promise<void>;
+        stat(path: string): Promise<Stats>;
+        lstat(path: string): Promise<Stats>;
+        unlink(path: string): Promise<void>;
+        rename(oldPath: string, newPath: string): Promise<void>;
+        copyFile(src: string, dest: string): Promise<void>;
+        cp(src: string, dest: string, options?: {
+            recursive?: boolean;
+            force?: boolean;
+            errorOnExist?: boolean;
+        }): Promise<void>;
+        mkdtemp(prefix: string, options?: nodeFs.EncodingOption): Promise<string>;
+        opendir(path: string, options?: nodeFs.OpenDirOptions): Promise<Dir>;
+        open(path: string, flags?: OpenFlags, mode?: Mode): Promise<FileHandle>;
+        statfs(path: string, options?: nodeFs.StatFsOptions): Promise<nodeFs.StatsFs>;
+        glob(pattern: string | string[], _options?: nodeFs.GlobOptionsWithFileTypes): Promise<string[]>;
+        access(path: string): Promise<void>;
+        rm(path: string, options?: {
+            force?: boolean;
+            recursive?: boolean;
+        }): Promise<void>;
+        chmod(path: string, mode: Mode): Promise<void>;
+        chown(path: string, uid: number, gid: number): Promise<void>;
+        lchown(path: string, uid: number, gid: number): Promise<void>;
+        link(existingPath: string, newPath: string): Promise<void>;
+        symlink(target: string, path: string): Promise<void>;
+        readlink(path: string): Promise<string>;
+        truncate(path: string, len?: number): Promise<void>;
+        utimes(path: string, atime: string | number | Date, mtime: string | number | Date): Promise<void>;
+        watch(path: unknown, options?: unknown): AsyncIterableIterator<{
+            eventType: string;
+            filename: string | Buffer | null;
+        }>;
+    };
+    accessSync(path: string): void;
+    access(path: string, mode?: number | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    realpathSync: ((path: PathLike, options?: nodeFs.EncodingOption) => string) & {
+        native(path: PathLike, options?: nodeFs.EncodingOption): string;
+    };
+    realpath: ((path: PathLike, optionsOrCallback?: nodeFs.EncodingOption | NodeCallback<string>, callback?: NodeCallback<string>) => Promise<string> | void) & {
+        native(path: PathLike, optionsOrCallback?: nodeFs.EncodingOption | NodeCallback<string>, callback?: NodeCallback<string>): Promise<string> | void;
+    };
+    ReadStream: {
+        (path: string | Buffer | null, options?: {
+            encoding?: BufferEncoding;
+            start?: number;
+            end?: number;
+            highWaterMark?: number;
+            bufferSize?: number;
+            autoClose?: boolean;
+            fd?: number | FileHandle;
+            fs?: unknown;
+            signal?: AbortSignal;
+        }): ReadStream;
+        prototype: ReadStream;
+    };
+    WriteStream: {
+        (path: string | Buffer | null, options?: {
+            encoding?: BufferEncoding;
+            flags?: string;
+            mode?: number;
+            fd?: number | FileHandle;
+            fs?: unknown;
+            autoClose?: boolean;
+        }): WriteStream;
+        prototype: WriteStream;
+    };
+    createReadStream: (path: nodeFs.PathLike, options?: BufferEncoding | {
+        encoding?: BufferEncoding;
+        start?: number;
+        end?: number;
+        highWaterMark?: number;
+        bufferSize?: number;
+        autoClose?: boolean;
+        fd?: number | FileHandle;
+        fs?: unknown;
+        signal?: AbortSignal;
+    }) => nodeFs.ReadStream;
+    createWriteStream: (path: nodeFs.PathLike, options?: BufferEncoding | {
+        encoding?: BufferEncoding;
+        flags?: string;
+        mode?: number;
+        autoClose?: boolean;
+        fd?: number | FileHandle;
+        fs?: unknown;
+    }) => nodeFs.WriteStream;
+    watch(..._args: unknown[]): never;
+    watchFile(..._args: unknown[]): never;
+    unwatchFile(..._args: unknown[]): never;
+    chmod(path: PathLike, mode: Mode, callback?: NodeCallback<void>): Promise<void> | void;
+    chown(path: PathLike, uid: number, gid: number, callback?: NodeCallback<void>): Promise<void> | void;
+    fchmod(fd: number, mode: Mode, callback?: NodeCallback<void>): Promise<void> | void;
+    fchown(fd: number, uid: number, gid: number, callback?: NodeCallback<void>): Promise<void> | void;
+    lchown(path: PathLike, uid: number, gid: number, callback?: NodeCallback<void>): Promise<void> | void;
+    link(existingPath: PathLike, newPath: PathLike, callback?: NodeCallback<void>): Promise<void> | void;
+    symlink(target: PathLike, path: PathLike, typeOrCb?: string | null | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    readlink(path: PathLike, optionsOrCb?: nodeFs.EncodingOption | NodeCallback<string>, callback?: NodeCallback<string>): Promise<string> | void;
+    truncate(path: PathLike, lenOrCb?: number | null | NodeCallback<void>, callback?: NodeCallback<void>): Promise<void> | void;
+    utimes(path: PathLike, atime: string | number | Date, mtime: string | number | Date, callback?: NodeCallback<void>): Promise<void> | void;
+};
+export default fs;