@psnext/slingcli 3.1.20260904-1 → 3.3.20260911-1

package/node_modules/@types/node/fs.d.ts

@@ -1,28 +1,49 @@
-declare module "node:fs" {
-    import { BufferView, NonSharedBuffer } from "node:buffer";
-    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
-    import { FileHandle } from "node:fs/promises";
+/**
+ * The `node:fs` module enables interacting with the file system in a
+ * way modeled on standard POSIX functions.
+ *
+ * To use the promise-based APIs:
+ *
+ * ```js
+ * import * as fs from 'node:fs/promises';
+ * ```
+ *
+ * To use the callback and sync APIs:
+ *
+ * ```js
+ * import * as fs from 'node:fs';
+ * ```
+ *
+ * All file system operations have synchronous, callback, and promise-based
+ * forms, and are accessible using both CommonJS syntax and ES6 Modules (ESM).
+ * @see [source](https://github.com/nodejs/node/blob/v22.x/lib/fs.js)
+ */
+declare module "fs" {
+    import { NonSharedBuffer } from "node:buffer";
     import * as stream from "node:stream";
+    import { Abortable, EventEmitter } from "node:events";
     import { URL } from "node:url";
+    import * as promises from "node:fs/promises";
+    export { promises };
     /**
      * Valid types for path values in "fs".
      */
-    type PathLike = string | Buffer | URL;
-    type PathOrFileDescriptor = PathLike | number;
-    type TimeLike = string | number | Date;
-    type NoParamCallback = (err: NodeJS.ErrnoException | null) => void;
-    type BufferEncodingOption =
+    export type PathLike = string | Buffer | URL;
+    export type PathOrFileDescriptor = PathLike | number;
+    export type TimeLike = string | number | Date;
+    export type NoParamCallback = (err: NodeJS.ErrnoException | null) => void;
+    export type BufferEncodingOption =
         | "buffer"
         | {
             encoding: "buffer";
         };
-    interface ObjectEncodingOptions {
+    export interface ObjectEncodingOptions {
         encoding?: BufferEncoding | null | undefined;
     }
-    type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
-    type OpenMode = number | string;
-    type Mode = number | string;
-    interface StatsBase<T> {
+    export type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
+    export type OpenMode = number | string;
+    export type Mode = number | string;
+    export interface StatsBase<T> {
         isFile(): boolean;
         isDirectory(): boolean;
         isBlockDevice(): boolean;
@@ -48,15 +69,8 @@ declare module "node:fs" {
         mtime: Date;
         ctime: Date;
         birthtime: Date;
-        // Deliberately not defining a type alias here... it'd be exported, and something in the ecosystem would inevitably start using it.
-        // TODO: replace with Temporal builtins once @types/node no longer supports TS <6.0.
-        atimeInstant: typeof globalThis extends { Temporal: { Instant: new(...args: any[]) => infer T } } ? T : unknown;
-        mtimeInstant: typeof globalThis extends { Temporal: { Instant: new(...args: any[]) => infer T } } ? T : unknown;
-        ctimeInstant: typeof globalThis extends { Temporal: { Instant: new(...args: any[]) => infer T } } ? T : unknown;
-        birthtimeInstant: typeof globalThis extends { Temporal: { Instant: new(...args: any[]) => infer T } } ? T
-            : unknown;
     }
-    interface Stats extends StatsBase<number> {}
+    export interface Stats extends StatsBase<number> {}
     /**
      * A `fs.Stats` object provides information about a file.
      *
@@ -117,10 +131,10 @@ declare module "node:fs" {
      * ```
      * @since v0.1.21
      */
-    class Stats {
+    export class Stats {
         private constructor();
     }
-    interface StatsFsBase<T> {
+    export interface StatsFsBase<T> {
         /** Type of file system. */
         type: T;
         /**  Optimal transfer block size. */
@@ -133,12 +147,10 @@ declare module "node:fs" {
         bavail: T;
         /** Total file nodes in file system. */
         files: T;
-        /** Fundamental file system block size. */
-        frsize: T;
         /** Free file nodes in file system. */
         ffree: T;
     }
-    interface StatsFs extends StatsFsBase<number> {}
+    export interface StatsFs extends StatsFsBase<number> {}
     /**
      * Provides information about a mounted file system.
      *
@@ -173,9 +185,9 @@ declare module "node:fs" {
      * ```
      * @since v19.6.0, v18.15.0
      */
-    class StatsFs {}
-    interface BigIntStatsFs extends StatsFsBase<bigint> {}
-    interface StatFsOptions {
+    export class StatsFs {}
+    export interface BigIntStatsFs extends StatsFsBase<bigint> {}
+    export interface StatFsOptions {
         bigint?: boolean | undefined;
     }
     /**
@@ -187,7 +199,7 @@ declare module "node:fs" {
      * the `withFileTypes` option set to `true`, the resulting array is filled with `fs.Dirent` objects, rather than strings or `Buffer` s.
      * @since v10.10.0
      */
-    class Dirent<Name extends string | Buffer = string> {
+    export class Dirent<Name extends string | Buffer = string> {
         /**
          * Returns `true` if the `fs.Dirent` object describes a regular file.
          * @since v10.10.0
@@ -236,6 +248,12 @@ declare module "node:fs" {
          * @since v20.12.0, v18.20.0
          */
         parentPath: string;
+        /**
+         * Alias for `dirent.parentPath`.
+         * @since v20.1.0
+         * @deprecated Since v20.12.0
+         */
+        path: string;
     }
     /**
      * A class representing a directory stream.
@@ -258,7 +276,7 @@ declare module "node:fs" {
      * closed after the iterator exits.
      * @since v12.12.0
      */
-    class Dir implements AsyncIterable<Dirent> {
+    export class Dir implements AsyncIterable<Dirent> {
         /**
          * The read-only path of this directory as was provided to {@link opendir},{@link opendirSync}, or `fsPromises.opendir()`.
          * @since v12.12.0
@@ -314,13 +332,15 @@ declare module "node:fs" {
         /**
          * Calls `dir.close()` if the directory handle is open, and returns a promise that
          * fulfills when disposal is complete.
-         * @since v24.1.0
+         * @since v22.17.0
+         * @experimental
          */
         [Symbol.asyncDispose](): Promise<void>;
         /**
          * Calls `dir.closeSync()` if the directory handle is open, and returns
          * `undefined`.
-         * @since v24.1.0
+         * @since v22.17.0
+         * @experimental
          */
         [Symbol.dispose](): void;
     }
@@ -330,7 +350,7 @@ declare module "node:fs" {
      * Extends `EventEmitter`
      * A successful call to {@link watchFile} method will return a new fs.StatWatcher object.
      */
-    interface StatWatcher extends EventEmitter {
+    export interface StatWatcher extends EventEmitter {
         /**
          * When called, requests that the Node.js event loop _not_ exit so long as the `fs.StatWatcher` is active. Calling `watcher.ref()` multiple times will have
          * no effect.
@@ -351,12 +371,7 @@ declare module "node:fs" {
          */
         unref(): this;
     }
-    interface FSWatcherEventMap {
-        "change": [eventType: string, filename: string | NonSharedBuffer];
-        "close": [];
-        "error": [error: Error];
-    }
-    interface FSWatcher extends InternalEventEmitter<FSWatcherEventMap> {
+    export interface FSWatcher extends EventEmitter {
         /**
          * Stop watching for changes on the given `fs.FSWatcher`. Once stopped, the `fs.FSWatcher` object is no longer usable.
          * @since v0.5.8
@@ -381,19 +396,44 @@ declare module "node:fs" {
          * @since v14.3.0, v12.20.0
          */
         unref(): this;
-    }
-    interface ReadStreamEventMap extends stream.ReadableEventMap {
-        "close": [];
-        "data": [chunk: string | NonSharedBuffer];
-        "open": [fd: number];
-        "ready": [];
+        /**
+         * events.EventEmitter
+         *   1. change
+         *   2. close
+         *   3. error
+         */
+        addListener(event: string, listener: (...args: any[]) => void): this;
+        addListener(event: "change", listener: (eventType: string, filename: string | NonSharedBuffer) => void): this;
+        addListener(event: "close", listener: () => void): this;
+        addListener(event: "error", listener: (error: Error) => void): this;
+        on(event: string, listener: (...args: any[]) => void): this;
+        on(event: "change", listener: (eventType: string, filename: string | NonSharedBuffer) => void): this;
+        on(event: "close", listener: () => void): this;
+        on(event: "error", listener: (error: Error) => void): this;
+        once(event: string, listener: (...args: any[]) => void): this;
+        once(event: "change", listener: (eventType: string, filename: string | NonSharedBuffer) => void): this;
+        once(event: "close", listener: () => void): this;
+        once(event: "error", listener: (error: Error) => void): this;
+        prependListener(event: string, listener: (...args: any[]) => void): this;
+        prependListener(
+            event: "change",
+            listener: (eventType: string, filename: string | NonSharedBuffer) => void,
+        ): this;
+        prependListener(event: "close", listener: () => void): this;
+        prependListener(event: "error", listener: (error: Error) => void): this;
+        prependOnceListener(event: string, listener: (...args: any[]) => void): this;
+        prependOnceListener(
+            event: "change",
+            listener: (eventType: string, filename: string | NonSharedBuffer) => void,
+        ): this;
+        prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (error: Error) => void): this;
     }
     /**
-     * Instances of `fs.ReadStream` cannot be constructed directly. They are created and
-     * returned using the `fs.createReadStream()` function.
+     * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function.
      * @since v0.1.93
      */
-    class ReadStream extends stream.Readable {
+    export class ReadStream extends stream.Readable {
         close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
         /**
          * The number of bytes that have been read so far.
@@ -413,251 +453,60 @@ declare module "node:fs" {
          * @since v11.2.0, v10.16.0
          */
         pending: boolean;
-        // #region InternalEventEmitter
-        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)[];
-        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-        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;
-        // #endregion
-    }
-    interface Utf8StreamOptions {
-        /**
-         * Appends writes to dest file instead of truncating it.
-         * @default true
-         */
-        append?: boolean | undefined;
-        /**
-         * Which type of data you can send to the write
-         * function, supported values are `'utf8'` or `'buffer'`.
-         * @default 'utf8'
-         */
-        contentMode?: "utf8" | "buffer" | undefined;
-        /**
-         * A path to a file to be written to (mode controlled by the
-         * append option).
-         */
-        dest?: string | undefined;
-        /**
-         * A file descriptor, something that is returned by `fs.open()`
-         * or `fs.openSync()`.
-         */
-        fd?: number | undefined;
-        /**
-         * An object that has the same API as the `fs` module, useful
-         * for mocking, testing, or customizing the behavior of the stream.
-         */
-        fs?: object | undefined;
-        /**
-         * Perform a `fs.fsyncSync()` every time a write is
-         * completed.
-         */
-        fsync?: boolean | undefined;
-        /**
-         * The maximum length of the internal buffer. If a write
-         * operation would cause the buffer to exceed `maxLength`, the data written is
-         * dropped and a drop event is emitted with the dropped data
-         */
-        maxLength?: number | undefined;
-        /**
-         * The maximum number of bytes that can be written;
-         * @default 16384
-         */
-        maxWrite?: number | undefined;
-        /**
-         * The minimum length of the internal buffer that is
-         * required to be full before flushing.
-         */
-        minLength?: number | undefined;
-        /**
-         * Ensure directory for `dest` file exists when true.
-         * @default false
-         */
-        mkdir?: boolean | undefined;
-        /**
-         * Specify the creating file mode (see `fs.open()`).
-         */
-        mode?: number | string | undefined;
         /**
-         * Calls flush every `periodicFlush` milliseconds.
+         * events.EventEmitter
+         *   1. open
+         *   2. close
+         *   3. ready
          */
-        periodicFlush?: number | undefined;
-        /**
-         * A function that will be called when `write()`,
-         * `writeSync()`, or `flushSync()` encounters an `EAGAIN` or `EBUSY` error.
-         * If the return value is `true` the operation will be retried, otherwise it
-         * will bubble the error. The `err` is the error that caused this function to
-         * be called, `writeBufferLen` is the length of the buffer that was written,
-         * and `remainingBufferLen` is the length of the remaining buffer that the
-         * stream did not try to write.
-         */
-        retryEAGAIN?: ((err: Error | null, writeBufferLen: number, remainingBufferLen: number) => boolean) | undefined;
-        /**
-         * Perform writes synchronously.
-         */
-        sync?: boolean | undefined;
-    }
-    interface Utf8StreamEventMap {
-        "close": [];
-        "drain": [];
-        "drop": [data: string | Buffer];
-        "error": [error: Error];
-        "finish": [];
-        "ready": [];
-        "write": [n: number];
+        addListener<K extends keyof ReadStreamEvents>(event: K, listener: ReadStreamEvents[K]): this;
+        on<K extends keyof ReadStreamEvents>(event: K, listener: ReadStreamEvents[K]): this;
+        once<K extends keyof ReadStreamEvents>(event: K, listener: ReadStreamEvents[K]): this;
+        prependListener<K extends keyof ReadStreamEvents>(event: K, listener: ReadStreamEvents[K]): this;
+        prependOnceListener<K extends keyof ReadStreamEvents>(event: K, listener: ReadStreamEvents[K]): this;
     }
+
     /**
-     * An optimized UTF-8 stream writer that allows for flushing all the internal
-     * buffering on demand. It handles `EAGAIN` errors correctly, allowing for
-     * customization, for example, by dropping content if the disk is busy.
-     * @since v24.6.0
-     * @experimental
+     * The Keys are events of the ReadStream and the values are the functions that are called when the event is emitted.
+     */
+    type ReadStreamEvents = {
+        close: () => void;
+        data: (chunk: Buffer | string) => void;
+        end: () => void;
+        error: (err: Error) => void;
+        open: (fd: number) => void;
+        pause: () => void;
+        readable: () => void;
+        ready: () => void;
+        resume: () => void;
+    } & CustomEvents;
+
+    /**
+     * string & {} allows to allow any kind of strings for the event
+     * but still allows to have auto completion for the normal events.
      */
-    class Utf8Stream implements EventEmitter {
-        constructor(options: Utf8StreamOptions);
-        /**
-         * Whether the stream is appending to the file or truncating it.
-         */
-        readonly append: boolean;
-        /**
-         * The type of data that can be written to the stream. Supported
-         * values are `'utf8'` or `'buffer'`.
-         * @default 'utf8'
-         */
-        readonly contentMode: "utf8" | "buffer";
-        /**
-         * Close the stream immediately, without flushing the internal buffer.
-         */
-        destroy(): void;
-        /**
-         * Close the stream gracefully, flushing the internal buffer before closing.
-         */
-        end(): void;
-        /**
-         * The file descriptor that is being written to.
-         */
-        readonly fd: number;
-        /**
-         * The file that is being written to.
-         */
-        readonly file: string;
-        /**
-         * Writes the current buffer to the file if a write was not in progress. Do
-         * nothing if `minLength` is zero or if it is already writing.
-         */
-        flush(callback: (err: Error | null) => void): void;
-        /**
-         * Flushes the buffered data synchronously. This is a costly operation.
-         */
-        flushSync(): void;
-        /**
-         * Whether the stream is performing a `fs.fsyncSync()` after every
-         * write operation.
-         */
-        readonly fsync: boolean;
-        /**
-         * The maximum length of the internal buffer. If a write
-         * operation would cause the buffer to exceed `maxLength`, the data written is
-         * dropped and a drop event is emitted with the dropped data.
-         */
-        readonly maxLength: number;
-        /**
-         * The minimum length of the internal buffer that is required to be
-         * full before flushing.
-         */
-        readonly minLength: number;
-        /**
-         * Whether the stream should ensure that the directory for the
-         * `dest` file exists. If `true`, it will create the directory if it does not
-         * exist.
-         * @default false
-         */
-        readonly mkdir: boolean;
-        /**
-         * The mode of the file that is being written to.
-         */
-        readonly mode: number | string;
-        /**
-         * The number of milliseconds between flushes. If set to `0`, no
-         * periodic flushes will be performed.
-         */
-        readonly periodicFlush: number;
-        /**
-         * Reopen the file in place, useful for log rotation.
-         * @param file A path to a file to be written to (mode
-         * controlled by the append option).
-         */
-        reopen(file: PathLike): void;
-        /**
-         * Whether the stream is writing synchronously or asynchronously.
-         */
-        readonly sync: boolean;
-        /**
-         * When the `options.contentMode` is set to `'utf8'` when the stream is created,
-         * the `data` argument must be a string. If the `contentMode` is set to `'buffer'`,
-         * the `data` argument must be a `Buffer`.
-         * @param data The data to write.
-         */
-        write(data: string | Buffer): boolean;
-        /**
-         * Whether the stream is currently writing data to the file.
-         */
-        readonly writing: boolean;
-        /**
-         * Calls `utf8Stream.destroy()`.
-         */
-        [Symbol.dispose](): void;
-    }
-    interface Utf8Stream extends InternalEventEmitter<Utf8StreamEventMap> {}
-    interface WriteStreamEventMap extends stream.WritableEventMap {
-        "close": [];
-        "open": [fd: number];
-        "ready": [];
-    }
+    type CustomEvents = { [Key in string & {} | symbol]: (...args: any[]) => void };
+
+    /**
+     * The Keys are events of the WriteStream and the values are the functions that are called when the event is emitted.
+     */
+    type WriteStreamEvents = {
+        close: () => void;
+        drain: () => void;
+        error: (err: Error) => void;
+        finish: () => void;
+        open: (fd: number) => void;
+        pipe: (src: stream.Readable) => void;
+        ready: () => void;
+        unpipe: (src: stream.Readable) => void;
+    } & CustomEvents;
     /**
-     * Instances of `fs.WriteStream` cannot be constructed directly. They are created and
-     * returned using the `fs.createWriteStream()` function.
+     * * Extends `stream.Writable`
+     *
+     * Instances of `fs.WriteStream` are created and returned using the {@link createWriteStream} function.
      * @since v0.1.93
      */
-    class WriteStream extends stream.Writable {
+    export class WriteStream extends stream.Writable {
         /**
          * Closes `writeStream`. Optionally accepts a
          * callback that will be executed once the `writeStream`is closed.
@@ -683,57 +532,17 @@ declare module "node:fs" {
          * @since v11.2.0
          */
         pending: boolean;
-        // #region InternalEventEmitter
-        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)[];
-        // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-        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;
-        // #endregion
+        /**
+         * events.EventEmitter
+         *   1. open
+         *   2. close
+         *   3. ready
+         */
+        addListener<K extends keyof WriteStreamEvents>(event: K, listener: WriteStreamEvents[K]): this;
+        on<K extends keyof WriteStreamEvents>(event: K, listener: WriteStreamEvents[K]): this;
+        once<K extends keyof WriteStreamEvents>(event: K, listener: WriteStreamEvents[K]): this;
+        prependListener<K extends keyof WriteStreamEvents>(event: K, listener: WriteStreamEvents[K]): this;
+        prependOnceListener<K extends keyof WriteStreamEvents>(event: K, listener: WriteStreamEvents[K]): this;
     }
     /**
      * Asynchronously rename file at `oldPath` to the pathname provided
@@ -754,8 +563,8 @@ declare module "node:fs" {
      * ```
      * @since v0.0.2
      */
-    function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
-    namespace rename {
+    export function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
+    export namespace rename {
         /**
          * Asynchronous rename(2) - Change the name or location of a file or directory.
          * @param oldPath A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -771,7 +580,7 @@ declare module "node:fs" {
      * See the POSIX [`rename(2)`](http://man7.org/linux/man-pages/man2/rename.2.html) documentation for more details.
      * @since v0.1.21
      */
-    function renameSync(oldPath: PathLike, newPath: PathLike): void;
+    export function renameSync(oldPath: PathLike, newPath: PathLike): void;
     /**
      * Truncates the file. No arguments other than a possible exception are
      * given to the completion callback. A file descriptor can also be passed as the
@@ -793,13 +602,13 @@ declare module "node:fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    function truncate(path: PathLike, len: number | undefined, callback: NoParamCallback): void;
+    export function truncate(path: PathLike, len: number | undefined, callback: NoParamCallback): void;
     /**
      * Asynchronous truncate(2) - Truncate a file to a specified length.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    function truncate(path: PathLike, callback: NoParamCallback): void;
-    namespace truncate {
+    export function truncate(path: PathLike, callback: NoParamCallback): void;
+    export namespace truncate {
         /**
          * Asynchronous truncate(2) - Truncate a file to a specified length.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -816,7 +625,7 @@ declare module "node:fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    function truncateSync(path: PathLike, len?: number): void;
+    export function truncateSync(path: PathLike, len?: number): void;
     /**
      * Truncates the file descriptor. No arguments other than a possible exception are
      * given to the completion callback.
@@ -860,13 +669,13 @@ declare module "node:fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    function ftruncate(fd: number, len: number | undefined, callback: NoParamCallback): void;
+    export function ftruncate(fd: number, len: number | undefined, callback: NoParamCallback): void;
     /**
      * Asynchronous ftruncate(2) - Truncate a file to a specified length.
      * @param fd A file descriptor.
      */
-    function ftruncate(fd: number, callback: NoParamCallback): void;
-    namespace ftruncate {
+    export function ftruncate(fd: number, callback: NoParamCallback): void;
+    export namespace ftruncate {
         /**
          * Asynchronous ftruncate(2) - Truncate a file to a specified length.
          * @param fd A file descriptor.
@@ -882,7 +691,7 @@ declare module "node:fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    function ftruncateSync(fd: number, len?: number): void;
+    export function ftruncateSync(fd: number, len?: number): void;
     /**
      * Asynchronously changes owner and group of a file. No arguments other than a
      * possible exception are given to the completion callback.
@@ -890,8 +699,8 @@ declare module "node:fs" {
      * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail.
      * @since v0.1.97
      */
-    function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
-    namespace chown {
+    export function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
+    export namespace chown {
         /**
          * Asynchronous chown(2) - Change ownership of a file.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -905,7 +714,7 @@ declare module "node:fs" {
      * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail.
      * @since v0.1.97
      */
-    function chownSync(path: PathLike, uid: number, gid: number): void;
+    export function chownSync(path: PathLike, uid: number, gid: number): void;
     /**
      * Sets the owner of the file. No arguments other than a possible exception are
      * given to the completion callback.
@@ -913,8 +722,8 @@ declare module "node:fs" {
      * See the POSIX [`fchown(2)`](http://man7.org/linux/man-pages/man2/fchown.2.html) documentation for more detail.
      * @since v0.4.7
      */
-    function fchown(fd: number, uid: number, gid: number, callback: NoParamCallback): void;
-    namespace fchown {
+    export function fchown(fd: number, uid: number, gid: number, callback: NoParamCallback): void;
+    export namespace fchown {
         /**
          * Asynchronous fchown(2) - Change ownership of a file.
          * @param fd A file descriptor.
@@ -929,15 +738,15 @@ declare module "node:fs" {
      * @param uid The file's new owner's user id.
      * @param gid The file's new group's group id.
      */
-    function fchownSync(fd: number, uid: number, gid: number): void;
+    export function fchownSync(fd: number, uid: number, gid: number): void;
     /**
      * Set the owner of the symbolic link. No arguments other than a possible
      * exception are given to the completion callback.
      *
      * See the POSIX [`lchown(2)`](http://man7.org/linux/man-pages/man2/lchown.2.html) documentation for more detail.
      */
-    function lchown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
-    namespace lchown {
+    export function lchown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
+    export namespace lchown {
         /**
          * Asynchronous lchown(2) - Change ownership of a file. Does not dereference symbolic links.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -951,7 +760,7 @@ declare module "node:fs" {
      * @param uid The file's new owner's user id.
      * @param gid The file's new group's group id.
      */
-    function lchownSync(path: PathLike, uid: number, gid: number): void;
+    export function lchownSync(path: PathLike, uid: number, gid: number): void;
     /**
      * Changes the access and modification times of a file in the same way as {@link utimes}, with the difference that if the path refers to a symbolic
      * link, then the link is not dereferenced: instead, the timestamps of the
@@ -961,8 +770,8 @@ declare module "node:fs" {
      * callback.
      * @since v14.5.0, v12.19.0
      */
-    function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
-    namespace lutimes {
+    export function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    export namespace lutimes {
         /**
          * Changes the access and modification times of a file in the same way as `fsPromises.utimes()`,
          * with the difference that if the path refers to a symbolic link, then the link is not
@@ -979,7 +788,7 @@ declare module "node:fs" {
      * the operation fails. This is the synchronous version of {@link lutimes}.
      * @since v14.5.0, v12.19.0
      */
-    function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+    export function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
     /**
      * Asynchronously changes the permissions of a file. No arguments other than a
      * possible exception are given to the completion callback.
@@ -996,8 +805,8 @@ declare module "node:fs" {
      * ```
      * @since v0.1.30
      */
-    function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
-    namespace chmod {
+    export function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
+    export namespace chmod {
         /**
          * Asynchronous chmod(2) - Change permissions of a file.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1012,7 +821,7 @@ declare module "node:fs" {
      * See the POSIX [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html) documentation for more detail.
      * @since v0.6.7
      */
-    function chmodSync(path: PathLike, mode: Mode): void;
+    export function chmodSync(path: PathLike, mode: Mode): void;
     /**
      * Sets the permissions on the file. No arguments other than a possible exception
      * are given to the completion callback.
@@ -1020,8 +829,8 @@ declare module "node:fs" {
      * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail.
      * @since v0.4.7
      */
-    function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void;
-    namespace fchmod {
+    export function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void;
+    export namespace fchmod {
         /**
          * Asynchronous fchmod(2) - Change permissions of a file.
          * @param fd A file descriptor.
@@ -1035,7 +844,7 @@ declare module "node:fs" {
      * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail.
      * @since v0.4.7
      */
-    function fchmodSync(fd: number, mode: Mode): void;
+    export function fchmodSync(fd: number, mode: Mode): void;
     /**
      * Changes the permissions on a symbolic link. No arguments other than a possible
      * exception are given to the completion callback.
@@ -1045,9 +854,9 @@ declare module "node:fs" {
      * See the POSIX [`lchmod(2)`](https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2) documentation for more detail.
      * @deprecated Since v0.4.7
      */
-    function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
+    export function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
     /** @deprecated */
-    namespace lchmod {
+    export namespace lchmod {
         /**
          * Asynchronous lchmod(2) - Change permissions of a file. Does not dereference symbolic links.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1063,7 +872,7 @@ declare module "node:fs" {
      * See the POSIX [`lchmod(2)`](https://www.freebsd.org/cgi/man.cgi?query=lchmod&sektion=2) documentation for more detail.
      * @deprecated Since v0.4.7
      */
-    function lchmodSync(path: PathLike, mode: Mode): void;
+    export function lchmodSync(path: PathLike, mode: Mode): void;
     /**
      * Asynchronous [`stat(2)`](http://man7.org/linux/man-pages/man2/stat.2.html). The callback gets two arguments `(err, stats)` where`stats` is an `fs.Stats` object.
      *
@@ -1149,98 +958,48 @@ declare module "node:fs" {
      * ```
      * @since v0.0.2
      */
-    function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-    function stat(
+    export function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    export function stat(
         path: PathLike,
         options:
             | (StatOptions & {
                 bigint?: false | undefined;
-                throwIfNoEntry?: true | undefined;
             })
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
     ): void;
-    function stat(
+    export 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(
+    export function stat(
         path: PathLike,
         options: StatOptions | undefined,
-        callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats | undefined) => void,
+        callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void,
     ): void;
-    namespace stat {
-        // TODO: aliased promisify signatures
+    export namespace stat {
         /**
          * Asynchronous stat(2) - Get file status.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
          */
-        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>;
+        function __promisify__(path: PathLike, options?: StatOptions): Promise<Stats | BigIntStats>;
     }
-    /** @deprecated This orphaned interface will be removed in a future version. */
-    interface StatSyncFn extends Function {
+    export interface StatSyncFn extends Function {
         (path: PathLike, options?: undefined): Stats;
         (
             path: PathLike,
@@ -1281,50 +1040,15 @@ declare module "node:fs" {
      * Synchronous stat(2) - Get file status.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    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;
+    export const statSync: StatSyncFn;
     /**
      * Invokes the callback with the `fs.Stats` for the file descriptor.
      *
      * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail.
      * @since v0.1.95
      */
-    function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-    function fstat(
+    export function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    export function fstat(
         fd: number,
         options:
             | (StatOptions & {
@@ -1333,19 +1057,19 @@ declare module "node:fs" {
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
     ): void;
-    function fstat(
+    export function fstat(
         fd: number,
         options: StatOptions & {
             bigint: true;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void,
     ): void;
-    function fstat(
+    export function fstat(
         fd: number,
         options: StatOptions | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void,
     ): void;
-    namespace fstat {
+    export namespace fstat {
         /**
          * Asynchronous fstat(2) - Get file status.
          * @param fd A file descriptor.
@@ -1370,19 +1094,19 @@ declare module "node:fs" {
      * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail.
      * @since v0.1.95
      */
-    function fstatSync(
+    export function fstatSync(
         fd: number,
         options?: StatOptions & {
             bigint?: false | undefined;
         },
     ): Stats;
-    function fstatSync(
+    export function fstatSync(
         fd: number,
         options: StatOptions & {
             bigint: true;
         },
     ): BigIntStats;
-    function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
+    export function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
     /**
      * Retrieves the `fs.Stats` for the symbolic link referred to by the path.
      * The callback gets two arguments `(err, stats)` where `stats` is a `fs.Stats` object. `lstat()` is identical to `stat()`, except that if `path` is a symbolic
@@ -1391,8 +1115,8 @@ declare module "node:fs" {
      * See the POSIX [`lstat(2)`](http://man7.org/linux/man-pages/man2/lstat.2.html) documentation for more details.
      * @since v0.1.30
      */
-    function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-    function lstat(
+    export function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    export function lstat(
         path: PathLike,
         options:
             | (StatOptions & {
@@ -1401,19 +1125,19 @@ declare module "node:fs" {
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
     ): void;
-    function lstat(
+    export function lstat(
         path: PathLike,
         options: StatOptions & {
             bigint: true;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void,
     ): void;
-    function lstat(
+    export function lstat(
         path: PathLike,
         options: StatOptions | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void,
     ): void;
-    namespace lstat {
+    export namespace lstat {
         /**
          * Asynchronous lstat(2) - Get file status. Does not dereference symbolic links.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1440,8 +1164,8 @@ declare module "node:fs" {
      * @since v19.6.0, v18.15.0
      * @param path A path to an existing file or directory on the file system to be queried.
      */
-    function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
-    function statfs(
+    export function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
+    export function statfs(
         path: PathLike,
         options:
             | (StatFsOptions & {
@@ -1450,19 +1174,19 @@ declare module "node:fs" {
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void,
     ): void;
-    function statfs(
+    export function statfs(
         path: PathLike,
         options: StatFsOptions & {
             bigint: true;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatsFs) => void,
     ): void;
-    function statfs(
+    export function statfs(
         path: PathLike,
         options: StatFsOptions | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: StatsFs | BigIntStatsFs) => void,
     ): void;
-    namespace statfs {
+    export namespace statfs {
         /**
          * Asynchronous statfs(2) - Returns information about the mounted file system which contains path. The callback gets two arguments (err, stats) where stats is an <fs.StatFs> object.
          * @param path A path to an existing file or directory on the file system to be queried.
@@ -1489,67 +1213,32 @@ declare module "node:fs" {
      * @since v19.6.0, v18.15.0
      * @param path A path to an existing file or directory on the file system to be queried.
      */
-    function statfsSync(
+    export function statfsSync(
         path: PathLike,
         options?: StatFsOptions & {
             bigint?: false | undefined;
         },
     ): StatsFs;
-    function statfsSync(
+    export function statfsSync(
         path: PathLike,
         options: StatFsOptions & {
             bigint: true;
         },
     ): BigIntStatsFs;
-    function statfsSync(path: PathLike, options?: StatFsOptions): StatsFs | BigIntStatsFs;
+    export function statfsSync(path: PathLike, options?: StatFsOptions): StatsFs | BigIntStatsFs;
     /**
      * Synchronous lstat(2) - Get file status. Does not dereference symbolic links.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    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;
+    export const lstatSync: StatSyncFn;
     /**
      * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. No arguments other than
      * a possible
      * exception are given to the completion callback.
      * @since v0.1.31
      */
-    function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
-    namespace link {
+    export function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
+    export namespace link {
         /**
          * Asynchronous link(2) - Create a new link (also known as a hard link) to an existing file.
          * @param existingPath A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1561,7 +1250,7 @@ declare module "node:fs" {
      * Creates a new link from the `existingPath` to the `newPath`. See the POSIX [`link(2)`](http://man7.org/linux/man-pages/man2/link.2.html) documentation for more detail. Returns `undefined`.
      * @since v0.1.31
      */
-    function linkSync(existingPath: PathLike, newPath: PathLike): void;
+    export function linkSync(existingPath: PathLike, newPath: PathLike): void;
     /**
      * Creates the link called `path` pointing to `target`. No arguments other than a
      * possible exception are given to the completion callback.
@@ -1595,7 +1284,7 @@ declare module "node:fs" {
      * @since v0.1.31
      * @param [type='null']
      */
-    function symlink(
+    export function symlink(
         target: PathLike,
         path: PathLike,
         type: symlink.Type | undefined | null,
@@ -1606,8 +1295,8 @@ declare module "node:fs" {
      * @param target A path to an existing file. If a URL is provided, it must use the `file:` protocol.
      * @param path A path to the new symlink. If a URL is provided, it must use the `file:` protocol.
      */
-    function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
-    namespace symlink {
+    export function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
+    export namespace symlink {
         /**
          * Asynchronous symlink(2) - Create a new symbolic link to an existing file.
          * @param target A path to an existing file. If a URL is provided, it must use the `file:` protocol.
@@ -1626,7 +1315,7 @@ declare module "node:fs" {
      * @since v0.1.31
      * @param [type='null']
      */
-    function symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type | null): void;
+    export function symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type | null): void;
     /**
      * Reads the contents of the symbolic link referred to by `path`. The callback gets
      * two arguments `(err, linkString)`.
@@ -1639,7 +1328,7 @@ declare module "node:fs" {
      * the link path returned will be passed as a `Buffer` object.
      * @since v0.1.31
      */
-    function readlink(
+    export function readlink(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, linkString: string) => void,
@@ -1649,7 +1338,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readlink(
+    export function readlink(
         path: PathLike,
         options: BufferEncodingOption,
         callback: (err: NodeJS.ErrnoException | null, linkString: NonSharedBuffer) => void,
@@ -1659,7 +1348,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readlink(
+    export function readlink(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, linkString: string | NonSharedBuffer) => void,
@@ -1668,11 +1357,11 @@ declare module "node:fs" {
      * Asynchronous readlink(2) - read value of a symbolic link.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    function readlink(
+    export function readlink(
         path: PathLike,
         callback: (err: NodeJS.ErrnoException | null, linkString: string) => void,
     ): void;
-    namespace readlink {
+    export namespace readlink {
         /**
          * Asynchronous readlink(2) - read value of a symbolic link.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1703,19 +1392,19 @@ declare module "node:fs" {
      * the link path returned will be passed as a `Buffer` object.
      * @since v0.1.31
      */
-    function readlinkSync(path: PathLike, options?: EncodingOption): string;
+    export function readlinkSync(path: PathLike, options?: EncodingOption): string;
     /**
      * Synchronous readlink(2) - read value of a symbolic link.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readlinkSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+    export function readlinkSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
     /**
      * Synchronous readlink(2) - read value of a symbolic link.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readlinkSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    export function readlinkSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
     /**
      * Asynchronously computes the canonical pathname by resolving `.`, `..`, and
      * symbolic links.
@@ -1742,7 +1431,7 @@ declare module "node:fs" {
      * dependent name for that object.
      * @since v0.1.31
      */
-    function realpath(
+    export function realpath(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void,
@@ -1752,7 +1441,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function realpath(
+    export function realpath(
         path: PathLike,
         options: BufferEncodingOption,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: NonSharedBuffer) => void,
@@ -1762,7 +1451,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function realpath(
+    export function realpath(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: string | NonSharedBuffer) => void,
@@ -1771,11 +1460,11 @@ declare module "node:fs" {
      * Asynchronous realpath(3) - return the canonicalized absolute pathname.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    function realpath(
+    export function realpath(
         path: PathLike,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void,
     ): void;
-    namespace realpath {
+    export namespace realpath {
         /**
          * Asynchronous realpath(3) - return the canonicalized absolute pathname.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1838,20 +1527,20 @@ declare module "node:fs" {
      * this API: {@link realpath}.
      * @since v0.1.31
      */
-    function realpathSync(path: PathLike, options?: EncodingOption): string;
+    export function realpathSync(path: PathLike, options?: EncodingOption): string;
     /**
      * Synchronous realpath(3) - return the canonicalized absolute pathname.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function realpathSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+    export function realpathSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
     /**
      * Synchronous realpath(3) - return the canonicalized absolute pathname.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function realpathSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
-    namespace realpathSync {
+    export function realpathSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    export namespace realpathSync {
         function native(path: PathLike, options?: EncodingOption): string;
         function native(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
         function native(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
@@ -1875,8 +1564,8 @@ declare module "node:fs" {
      * See the POSIX [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html) documentation for more details.
      * @since v0.0.2
      */
-    function unlink(path: PathLike, callback: NoParamCallback): void;
-    namespace unlink {
+    export function unlink(path: PathLike, callback: NoParamCallback): void;
+    export namespace unlink {
         /**
          * Asynchronous unlink(2) - delete a name and possibly the file it refers to.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -1887,10 +1576,34 @@ declare module "node:fs" {
      * Synchronous [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html). Returns `undefined`.
      * @since v0.1.21
      */
-    function unlinkSync(path: PathLike): void;
-    /** @deprecated `rmdir()` no longer provides any options. This interface will be removed in a future version. */
-    // TODO: remove in future major
-    interface RmDirOptions {}
+    export function unlinkSync(path: PathLike): void;
+    export interface RmDirOptions {
+        /**
+         * If an `EBUSY`, `EMFILE`, `ENFILE`, `ENOTEMPTY`, or
+         * `EPERM` error is encountered, Node.js will retry the operation with a linear
+         * backoff wait of `retryDelay` ms longer on each try. This option represents the
+         * number of retries. This option is ignored if the `recursive` option is not
+         * `true`.
+         * @default 0
+         */
+        maxRetries?: number | undefined;
+        /**
+         * @deprecated since v14.14.0 In future versions of Node.js and will trigger a warning
+         * `fs.rmdir(path, { recursive: true })` will throw if `path` does not exist or is a file.
+         * Use `fs.rm(path, { recursive: true, force: true })` instead.
+         *
+         * If `true`, perform a recursive directory removal. In
+         * recursive mode, operations are retried on failure.
+         * @default false
+         */
+        recursive?: boolean | undefined;
+        /**
+         * The amount of time in milliseconds to wait between retries.
+         * This option is ignored if the `recursive` option is not `true`.
+         * @default 100
+         */
+        retryDelay?: number | undefined;
+    }
     /**
      * Asynchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). No arguments other than a possible exception are given
      * to the completion callback.
@@ -1901,13 +1614,14 @@ declare module "node:fs" {
      * To get a behavior similar to the `rm -rf` Unix command, use {@link rm} with options `{ recursive: true, force: true }`.
      * @since v0.0.2
      */
-    function rmdir(path: PathLike, callback: NoParamCallback): void;
-    namespace rmdir {
+    export function rmdir(path: PathLike, callback: NoParamCallback): void;
+    export function rmdir(path: PathLike, options: RmDirOptions, callback: NoParamCallback): void;
+    export namespace rmdir {
         /**
          * Asynchronous rmdir(2) - delete a directory.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
          */
-        function __promisify__(path: PathLike): Promise<void>;
+        function __promisify__(path: PathLike, options?: RmDirOptions): Promise<void>;
     }
     /**
      * Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`.
@@ -1918,8 +1632,8 @@ declare module "node:fs" {
      * To get a behavior similar to the `rm -rf` Unix command, use {@link rmSync} with options `{ recursive: true, force: true }`.
      * @since v0.1.21
      */
-    function rmdirSync(path: PathLike): void;
-    interface RmOptions {
+    export function rmdirSync(path: PathLike, options?: RmDirOptions): void;
+    export interface RmOptions {
         /**
          * When `true`, exceptions will be ignored if `path` does not exist.
          * @default false
@@ -1952,9 +1666,9 @@ declare module "node:fs" {
      * completion callback.
      * @since v14.14.0
      */
-    function rm(path: PathLike, callback: NoParamCallback): void;
-    function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
-    namespace rm {
+    export function rm(path: PathLike, callback: NoParamCallback): void;
+    export function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
+    export namespace rm {
         /**
          * Asynchronously removes files and directories (modeled on the standard POSIX `rm` utility).
          */
@@ -1964,8 +1678,8 @@ declare module "node:fs" {
      * Synchronously removes files and directories (modeled on the standard POSIX `rm` utility). Returns `undefined`.
      * @since v14.14.0
      */
-    function rmSync(path: PathLike, options?: RmOptions): void;
-    interface MakeDirectoryOptions {
+    export function rmSync(path: PathLike, options?: RmOptions): void;
+    export interface MakeDirectoryOptions {
         /**
          * Indicates whether parent folders should be created.
          * If a folder was created, the path to the first created folder will be returned.
@@ -2014,7 +1728,7 @@ declare module "node:fs" {
      * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
      * @since v0.1.8
      */
-    function mkdir(
+    export function mkdir(
         path: PathLike,
         options: MakeDirectoryOptions & {
             recursive: true;
@@ -2027,7 +1741,7 @@ declare module "node:fs" {
      * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
      * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
      */
-    function mkdir(
+    export function mkdir(
         path: PathLike,
         options:
             | Mode
@@ -2044,7 +1758,7 @@ declare module "node:fs" {
      * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
      * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
      */
-    function mkdir(
+    export function mkdir(
         path: PathLike,
         options: Mode | MakeDirectoryOptions | null | undefined,
         callback: (err: NodeJS.ErrnoException | null, path?: string) => void,
@@ -2053,8 +1767,8 @@ declare module "node:fs" {
      * Asynchronous mkdir(2) - create a directory with a mode of `0o777`.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    function mkdir(path: PathLike, callback: NoParamCallback): void;
-    namespace mkdir {
+    export function mkdir(path: PathLike, callback: NoParamCallback): void;
+    export namespace mkdir {
         /**
          * Asynchronous mkdir(2) - create a directory.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -2100,7 +1814,7 @@ declare module "node:fs" {
      * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
      * @since v0.1.21
      */
-    function mkdirSync(
+    export function mkdirSync(
         path: PathLike,
         options: MakeDirectoryOptions & {
             recursive: true;
@@ -2112,7 +1826,7 @@ declare module "node:fs" {
      * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
      * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
      */
-    function mkdirSync(
+    export function mkdirSync(
         path: PathLike,
         options?:
             | Mode
@@ -2127,7 +1841,7 @@ declare module "node:fs" {
      * @param options Either the file mode, or an object optionally specifying the file mode and whether parent folders
      * should be created. If a string is passed, it is parsed as an octal integer. If not specified, defaults to `0o777`.
      */
-    function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined;
+    export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined;
     /**
      * Creates a unique temporary directory.
      *
@@ -2187,7 +1901,7 @@ declare module "node:fs" {
      * ```
      * @since v5.10.0
      */
-    function mkdtemp(
+    export function mkdtemp(
         prefix: string,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, folder: string) => void,
@@ -2197,7 +1911,7 @@ declare module "node:fs" {
      * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function mkdtemp(
+    export function mkdtemp(
         prefix: string,
         options: BufferEncodingOption,
         callback: (err: NodeJS.ErrnoException | null, folder: NonSharedBuffer) => void,
@@ -2207,7 +1921,7 @@ declare module "node:fs" {
      * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function mkdtemp(
+    export function mkdtemp(
         prefix: string,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, folder: string | NonSharedBuffer) => void,
@@ -2216,11 +1930,11 @@ declare module "node:fs" {
      * Asynchronously creates a unique temporary directory.
      * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
      */
-    function mkdtemp(
+    export function mkdtemp(
         prefix: string,
         callback: (err: NodeJS.ErrnoException | null, folder: string) => void,
     ): void;
-    namespace mkdtemp {
+    export namespace mkdtemp {
         /**
          * Asynchronously creates a unique temporary directory.
          * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
@@ -2250,52 +1964,19 @@ declare module "node:fs" {
      * object with an `encoding` property specifying the character encoding to use.
      * @since v5.10.0
      */
-    function mkdtempSync(prefix: string, options?: EncodingOption): string;
+    export function mkdtempSync(prefix: string, options?: EncodingOption): string;
     /**
      * Synchronously creates a unique temporary directory.
      * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function mkdtempSync(prefix: string, options: BufferEncodingOption): NonSharedBuffer;
+    export function mkdtempSync(prefix: string, options: BufferEncodingOption): NonSharedBuffer;
     /**
      * Synchronously creates a unique temporary directory.
      * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function mkdtempSync(prefix: string, options?: EncodingOption): string | NonSharedBuffer;
-    interface DisposableTempDir extends Disposable {
-        /**
-         * The path of the created directory.
-         */
-        path: string;
-        /**
-         * A function which removes the created directory.
-         */
-        remove(): void;
-        /**
-         * The same as `remove`.
-         */
-        [Symbol.dispose](): void;
-    }
-    /**
-     * Returns a disposable object whose `path` property holds the created directory
-     * path. When the object is disposed, the directory and its contents will be
-     * removed if it still exists. If the directory cannot be deleted, disposal will
-     * throw an error. The object has a `remove()` method which will perform the same
-     * task.
-     *
-     * <!-- TODO: link MDN docs for disposables once https://github.com/mdn/content/pull/38027 lands -->
-     *
-     * For detailed information, see the documentation of `fs.mkdtemp()`.
-     *
-     * There is no callback-based version of this API because it is designed for use
-     * with the `using` syntax.
-     *
-     * The optional `options` argument can be a string specifying an encoding, or an
-     * object with an `encoding` property specifying the character encoding to use.
-     * @since v24.4.0
-     */
-    function mkdtempDisposableSync(prefix: string, options?: EncodingOption): DisposableTempDir;
+    export function mkdtempSync(prefix: string, options?: EncodingOption): string | NonSharedBuffer;
     /**
      * Reads the contents of a directory. The callback gets two arguments `(err, files)` where `files` is an array of the names of the files in the directory excluding `'.'` and `'..'`.
      *
@@ -2309,7 +1990,7 @@ declare module "node:fs" {
      * If `options.withFileTypes` is set to `true`, the `files` array will contain `fs.Dirent` objects.
      * @since v0.1.8
      */
-    function readdir(
+    export function readdir(
         path: PathLike,
         options:
             | {
@@ -2327,7 +2008,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readdir(
+    export function readdir(
         path: PathLike,
         options:
             | {
@@ -2343,7 +2024,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readdir(
+    export function readdir(
         path: PathLike,
         options:
             | (ObjectEncodingOptions & {
@@ -2359,7 +2040,7 @@ declare module "node:fs" {
      * Asynchronous readdir(3) - read a directory.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    function readdir(
+    export function readdir(
         path: PathLike,
         callback: (err: NodeJS.ErrnoException | null, files: string[]) => void,
     ): void;
@@ -2368,7 +2049,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options If called with `withFileTypes: true` the result data will be an array of Dirent.
      */
-    function readdir(
+    export function readdir(
         path: PathLike,
         options: ObjectEncodingOptions & {
             withFileTypes: true;
@@ -2381,7 +2062,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options Must include `withFileTypes: true` and `encoding: 'buffer'`.
      */
-    function readdir(
+    export function readdir(
         path: PathLike,
         options: {
             encoding: "buffer";
@@ -2390,7 +2071,7 @@ declare module "node:fs" {
         },
         callback: (err: NodeJS.ErrnoException | null, files: Dirent<NonSharedBuffer>[]) => void,
     ): void;
-    namespace readdir {
+    export namespace readdir {
         /**
          * Asynchronous readdir(3) - read a directory.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -2476,7 +2157,7 @@ declare module "node:fs" {
      * If `options.withFileTypes` is set to `true`, the result will contain `fs.Dirent` objects.
      * @since v0.1.21
      */
-    function readdirSync(
+    export function readdirSync(
         path: PathLike,
         options?:
             | {
@@ -2492,7 +2173,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readdirSync(
+    export function readdirSync(
         path: PathLike,
         options:
             | {
@@ -2507,7 +2188,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options The encoding (or an object specifying the encoding), used as the encoding of the result. If not provided, `'utf8'` is used.
      */
-    function readdirSync(
+    export function readdirSync(
         path: PathLike,
         options?:
             | (ObjectEncodingOptions & {
@@ -2522,7 +2203,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options If called with `withFileTypes: true` the result data will be an array of Dirent.
      */
-    function readdirSync(
+    export function readdirSync(
         path: PathLike,
         options: ObjectEncodingOptions & {
             withFileTypes: true;
@@ -2534,7 +2215,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param options Must include `withFileTypes: true` and `encoding: 'buffer'`.
      */
-    function readdirSync(
+    export function readdirSync(
         path: PathLike,
         options: {
             encoding: "buffer";
@@ -2552,8 +2233,8 @@ declare module "node:fs" {
      * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
      * @since v0.0.2
      */
-    function close(fd: number, callback?: NoParamCallback): void;
-    namespace close {
+    export function close(fd: number, callback?: NoParamCallback): void;
+    export namespace close {
         /**
          * Asynchronous close(2) - close a file descriptor.
          * @param fd A file descriptor.
@@ -2569,7 +2250,7 @@ declare module "node:fs" {
      * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
      * @since v0.1.21
      */
-    function closeSync(fd: number): void;
+    export function closeSync(fd: number): void;
     /**
      * Asynchronous file open. See the POSIX [`open(2)`](http://man7.org/linux/man-pages/man2/open.2.html) documentation for more details.
      *
@@ -2587,7 +2268,7 @@ declare module "node:fs" {
      * @param [flags='r'] See `support of file system `flags``.
      * @param [mode=0o666]
      */
-    function open(
+    export function open(
         path: PathLike,
         flags: OpenMode | undefined,
         mode: Mode | undefined | null,
@@ -2598,7 +2279,7 @@ declare module "node:fs" {
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      * @param [flags='r'] See `support of file system `flags``.
      */
-    function open(
+    export function open(
         path: PathLike,
         flags: OpenMode | undefined,
         callback: (err: NodeJS.ErrnoException | null, fd: number) => void,
@@ -2607,8 +2288,8 @@ declare module "node:fs" {
      * Asynchronous open(2) - open and possibly create a file. If the file is created, its mode will be `0o666`.
      * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
      */
-    function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
-    namespace open {
+    export function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    export namespace open {
         /**
          * Asynchronous open(2) - open and possibly create a file.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -2625,7 +2306,7 @@ declare module "node:fs" {
      * @param [flags='r']
      * @param [mode=0o666]
      */
-    function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
+    export function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
     /**
      * Change the file system timestamps of the object referenced by `path`.
      *
@@ -2635,8 +2316,8 @@ declare module "node:fs" {
      * * If the value can not be converted to a number, or is `NaN`, `Infinity`, or `-Infinity`, an `Error` will be thrown.
      * @since v0.4.2
      */
-    function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
-    namespace utimes {
+    export function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    export namespace utimes {
         /**
          * Asynchronously change file timestamps of the file referenced by the supplied path.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -2652,14 +2333,14 @@ declare module "node:fs" {
      * this API: {@link utimes}.
      * @since v0.4.2
      */
-    function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+    export function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
     /**
      * Change the file system timestamps of the object referenced by the supplied file
      * descriptor. See {@link utimes}.
      * @since v0.4.2
      */
-    function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
-    namespace futimes {
+    export function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    export namespace futimes {
         /**
          * Asynchronously change file timestamps of the file referenced by the supplied file descriptor.
          * @param fd A file descriptor.
@@ -2672,7 +2353,7 @@ declare module "node:fs" {
      * Synchronous version of {@link futimes}. Returns `undefined`.
      * @since v0.4.2
      */
-    function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void;
+    export function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void;
     /**
      * Request that all data for the open file descriptor is flushed to the storage
      * device. The specific implementation is operating system and device specific.
@@ -2680,8 +2361,8 @@ declare module "node:fs" {
      * than a possible exception are given to the completion callback.
      * @since v0.1.96
      */
-    function fsync(fd: number, callback: NoParamCallback): void;
-    namespace fsync {
+    export function fsync(fd: number, callback: NoParamCallback): void;
+    export namespace fsync {
         /**
          * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
          * @param fd A file descriptor.
@@ -2694,8 +2375,8 @@ declare module "node:fs" {
      * Refer to the POSIX [`fsync(2)`](http://man7.org/linux/man-pages/man2/fsync.2.html) documentation for more detail. Returns `undefined`.
      * @since v0.1.96
      */
-    function fsyncSync(fd: number): void;
-    interface WriteOptions {
+    export function fsyncSync(fd: number): void;
+    export interface WriteOptions {
         /**
          * @default 0
          */
@@ -2736,7 +2417,7 @@ declare module "node:fs" {
      * @param [length=buffer.byteLength - offset]
      * @param [position='null']
      */
-    function write<TBuffer extends NodeJS.ArrayBufferView>(
+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number | undefined | null,
@@ -2750,7 +2431,7 @@ declare module "node:fs" {
      * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
      * @param length The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
      */
-    function write<TBuffer extends NodeJS.ArrayBufferView>(
+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number | undefined | null,
@@ -2762,7 +2443,7 @@ declare module "node:fs" {
      * @param fd A file descriptor.
      * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
      */
-    function write<TBuffer extends NodeJS.ArrayBufferView>(
+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number | undefined | null,
@@ -2772,7 +2453,7 @@ declare module "node:fs" {
      * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
      * @param fd A file descriptor.
      */
-    function write<TBuffer extends NodeJS.ArrayBufferView>(
+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void,
@@ -2785,7 +2466,7 @@ declare module "node:fs" {
      * * `length` The number of bytes to write. If not supplied, defaults to `buffer.length - offset`.
      * * `position` The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
      */
-    function write<TBuffer extends NodeJS.ArrayBufferView>(
+    export function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         options: WriteOptions,
@@ -2798,7 +2479,7 @@ declare module "node:fs" {
      * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
      * @param encoding The expected string encoding.
      */
-    function write(
+    export function write(
         fd: number,
         string: string,
         position: number | undefined | null,
@@ -2811,7 +2492,7 @@ declare module "node:fs" {
      * @param string A string to write.
      * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
      */
-    function write(
+    export function write(
         fd: number,
         string: string,
         position: number | undefined | null,
@@ -2822,12 +2503,12 @@ declare module "node:fs" {
      * @param fd A file descriptor.
      * @param string A string to write.
      */
-    function write(
+    export function write(
         fd: number,
         string: string,
         callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void,
     ): void;
-    namespace write {
+    export namespace write {
         /**
          * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
          * @param fd A file descriptor.
@@ -2887,7 +2568,7 @@ declare module "node:fs" {
      * @param [position='null']
      * @return The number of bytes written.
      */
-    function writeSync(
+    export function writeSync(
         fd: number,
         buffer: NodeJS.ArrayBufferView,
         offset?: number | null,
@@ -2901,14 +2582,14 @@ declare module "node:fs" {
      * @param position The offset from the beginning of the file where this data should be written. If not supplied, defaults to the current position.
      * @param encoding The expected string encoding.
      */
-    function writeSync(
+    export function writeSync(
         fd: number,
         string: string,
         position?: number | null,
         encoding?: BufferEncoding | null,
     ): number;
-    type ReadPosition = number | bigint;
-    interface ReadOptions {
+    export type ReadPosition = number | bigint;
+    export interface ReadOptions {
         /**
          * @default 0
          */
@@ -2922,9 +2603,15 @@ declare module "node:fs" {
          */
         position?: ReadPosition | null | undefined;
     }
-    interface ReadOptionsWithBuffer<T extends NodeJS.ArrayBufferView> extends ReadOptions {
+    export interface ReadOptionsWithBuffer<T extends NodeJS.ArrayBufferView> extends ReadOptions {
         buffer?: T | undefined;
     }
+    /** @deprecated Use `ReadOptions` instead. */
+    // TODO: remove in future major
+    export interface ReadSyncOptions extends ReadOptions {}
+    /** @deprecated Use `ReadOptionsWithBuffer` instead. */
+    // TODO: remove in future major
+    export interface ReadAsyncOptions<T extends NodeJS.ArrayBufferView> extends ReadOptionsWithBuffer<T> {}
     /**
      * Read data from the file specified by `fd`.
      *
@@ -2942,7 +2629,7 @@ declare module "node:fs" {
      * @param position Specifies where to begin reading from in the file. If `position` is `null` or `-1 `, data will be read from the current file position, and the file position will be updated. If
      * `position` is an integer, the file position will be unchanged.
      */
-    function read<TBuffer extends NodeJS.ArrayBufferView>(
+    export function read<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number,
@@ -2959,27 +2646,27 @@ declare module "node:fs" {
      * `position` defaults to `null`
      * @since v12.17.0, 13.11.0
      */
-    function read<TBuffer extends NodeJS.ArrayBufferView = NonSharedBuffer>(
+    export 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>(
+    export 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>(
+    export function read<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void,
     ): void;
-    function read(
+    export function read(
         fd: number,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: NonSharedBuffer) => void,
     ): void;
-    namespace read {
+    export namespace read {
         /**
          * @param fd A file descriptor.
          * @param buffer The buffer that the data will be written to.
@@ -3017,7 +2704,7 @@ declare module "node:fs" {
      * @since v0.1.21
      * @param [position='null']
      */
-    function readSync(
+    export function readSync(
         fd: number,
         buffer: NodeJS.ArrayBufferView,
         offset: number,
@@ -3028,20 +2715,7 @@ declare module "node:fs" {
      * Similar to the above `fs.readSync` function, this version takes an optional `options` object.
      * If no `options` object is specified, it will default with the above values.
      */
-    function readSync(fd: number, buffer: NodeJS.ArrayBufferView, opts?: ReadOptions): number;
-    interface ReadFileOptions extends Abortable {
-        encoding?: BufferEncoding | null | undefined;
-        flag?: OpenMode | undefined;
-    }
-    interface ReadFileOptionsWithStringEncoding extends ReadFileOptions {
-        encoding: BufferEncoding;
-    }
-    interface ReadFileOptionsWithBufferEncoding extends ReadFileOptions {
-        encoding?: null | undefined;
-    }
-    interface ReadFileOptionsWithBuffer<T extends NodeJS.ArrayBufferView> extends ReadFileOptionsWithBufferEncoding {
-        buffer: T | ((size: number) => T);
-    }
+    export function readSync(fd: number, buffer: NodeJS.ArrayBufferView, opts?: ReadOptions): number;
     /**
      * Asynchronously reads the entire contents of a file.
      *
@@ -3059,11 +2733,6 @@ declare module "node:fs" {
      *
      * If no encoding is specified, then the raw buffer is returned.
      *
-     * If `buffer` is provided and no encoding is specified, the returned `Buffer` is
-     * a view over the supplied buffer containing only the bytes read. If the
-     * supplied buffer is too small to contain the entire file, the callback is
-     * called with an error.
-     *
      * If `options` is a string, then it specifies the encoding:
      *
      * ```js
@@ -3072,8 +2741,7 @@ declare module "node:fs" {
      * readFile('/etc/passwd', 'utf8', callback);
      * ```
      *
-     * When the path is a directory, the behavior of `fs.readFile()` and
-     * `fs.readFileSync()` is platform-specific. On macOS, Linux, and Windows, an
+     * When the path is a directory, the behavior of `fs.readFile()` and {@link readFileSync} is platform-specific. On macOS, Linux, and Windows, an
      * error will be returned. On FreeBSD, a representation of the directory's contents
      * will be returned.
      *
@@ -3111,61 +2779,65 @@ declare module "node:fs" {
      *
      * Aborting an ongoing request does not abort individual operating
      * system requests but rather the internal buffering `fs.readFile` performs.
-     *
-     * An example using the `buffer` option with a pre-allocated buffer:
-     *
-     * ```js
-     * import { Buffer } from 'node:buffer';
-     * import { readFile } from 'node:fs';
-     *
-     * const buf = Buffer.alloc(16384);
-     * readFile('/path/to/file', { buffer: buf }, (err, data) => {
-     *   if (err) throw err;
-     *   console.log(data); // A view over `buf` containing only the bytes read
-     * });
-     * ```
-     *
-     * An example using the `buffer` option with a function returning a buffer:
-     *
-     * ```js
-     * import { Buffer } from 'node:buffer';
-     * import { readFile } from 'node:fs';
-     *
-     * readFile('/path/to/file', {
-     *   buffer: (size) => Buffer.alloc(size),
-     * }, (err, data) => {
-     *   if (err) throw err;
-     *   console.log(data);
-     * });
-     * ```
      * @since v0.1.29
      * @param path filename or file descriptor
      */
-    function readFile<T extends NodeJS.ArrayBufferView>(
-        path: PathOrFileDescriptor,
-        options: ReadFileOptionsWithBuffer<T>,
-        callback: (err: NodeJS.ErrnoException | null, data: BufferView<T>) => void,
-    ): void;
-    function readFile(
+    export function readFile(
         path: PathOrFileDescriptor,
-        options: ReadFileOptionsWithBufferEncoding | null | undefined,
+        options:
+            | ({
+                encoding?: null | undefined;
+                flag?: string | undefined;
+            } & Abortable)
+            | undefined
+            | null,
         callback: (err: NodeJS.ErrnoException | null, data: NonSharedBuffer) => void,
     ): void;
-    function readFile(
+    /**
+     * Asynchronously reads the entire contents of a file.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
+     * If a flag is not provided, it defaults to `'r'`.
+     */
+    export function readFile(
         path: PathOrFileDescriptor,
-        options: ReadFileOptionsWithStringEncoding | BufferEncoding,
+        options:
+            | ({
+                encoding: BufferEncoding;
+                flag?: string | undefined;
+            } & Abortable)
+            | BufferEncoding,
         callback: (err: NodeJS.ErrnoException | null, data: string) => void,
     ): void;
-    function readFile(
+    /**
+     * Asynchronously reads the entire contents of a file.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
+     * If a flag is not provided, it defaults to `'r'`.
+     */
+    export function readFile(
         path: PathOrFileDescriptor,
-        options: ReadFileOptions | BufferEncoding | null | undefined,
+        options:
+            | (ObjectEncodingOptions & {
+                flag?: string | undefined;
+            } & Abortable)
+            | BufferEncoding
+            | undefined
+            | null,
         callback: (err: NodeJS.ErrnoException | null, data: string | NonSharedBuffer) => void,
     ): void;
-    function readFile(
+    /**
+     * Asynchronously reads the entire contents of a file.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
+     */
+    export function readFile(
         path: PathOrFileDescriptor,
         callback: (err: NodeJS.ErrnoException | null, data: NonSharedBuffer) => void,
     ): void;
-    namespace readFile {
+    export namespace readFile {
         /**
          * Asynchronously reads the entire contents of a file.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -3215,37 +2887,16 @@ declare module "node:fs" {
                 | null,
         ): Promise<string | NonSharedBuffer>;
     }
-    interface ReadFileSyncOptions {
-        encoding?: BufferEncoding | null | undefined;
-        flag?: OpenMode | undefined;
-    }
-    interface ReadFileSyncOptionsWithStringEncoding extends ReadFileSyncOptions {
-        encoding: BufferEncoding;
-    }
-    interface ReadFileSyncOptionsWithBufferEncoding extends ReadFileSyncOptions {
-        encoding?: null | undefined;
-    }
-    interface ReadFileSyncOptionsWithBuffer<T extends NodeJS.ArrayBufferView>
-        extends ReadFileSyncOptionsWithBufferEncoding
-    {
-        buffer: T | ((size: number) => T);
-    }
     /**
      * Returns the contents of the `path`.
      *
      * For detailed information, see the documentation of the asynchronous version of
-     * this API: `fs.readFile()`.
+     * this API: {@link readFile}.
      *
      * If the `encoding` option is specified then this function returns a
      * string. Otherwise it returns a buffer.
      *
-     * If `buffer` is provided and no encoding is specified, the returned {Buffer} is
-     * a view over the supplied buffer containing only the bytes read. If the
-     * supplied buffer is too small to contain the entire file, an error will be
-     * thrown.
-     *
-     * Similar to `fs.readFile()`, when the path is a directory, the behavior of
-     * `fs.readFileSync()` is platform-specific.
+     * Similar to {@link readFile}, when the path is a directory, the behavior of `fs.readFileSync()` is platform-specific.
      *
      * ```js
      * import { readFileSync } from 'node:fs';
@@ -3260,20 +2911,46 @@ declare module "node:fs" {
      * @since v0.1.8
      * @param path filename or file descriptor
      */
-    function readFileSync<T extends NodeJS.ArrayBufferView>(
-        path: PathOrFileDescriptor,
-        options: ReadFileSyncOptionsWithBuffer<T>,
-    ): BufferView<T>;
-    function readFileSync(
+    export function readFileSync(
         path: PathOrFileDescriptor,
-        options?: ReadFileSyncOptionsWithBufferEncoding | null,
+        options?: {
+            encoding?: null | undefined;
+            flag?: string | undefined;
+        } | null,
     ): NonSharedBuffer;
-    function readFileSync(
+    /**
+     * Synchronously reads the entire contents of a file.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
+     * If a flag is not provided, it defaults to `'r'`.
+     */
+    export function readFileSync(
         path: PathOrFileDescriptor,
-        options: ReadFileSyncOptionsWithStringEncoding | BufferEncoding,
+        options:
+            | {
+                encoding: BufferEncoding;
+                flag?: string | undefined;
+            }
+            | BufferEncoding,
     ): string;
-    function readFileSync(path: PathOrFileDescriptor, options: ReadFileSyncOptions): string | NonSharedBuffer;
-    type WriteFileOptions =
+    /**
+     * Synchronously reads the entire contents of a file.
+     * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
+     * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
+     * @param options Either the encoding for the result, or an object that contains the encoding and an optional flag.
+     * If a flag is not provided, it defaults to `'r'`.
+     */
+    export function readFileSync(
+        path: PathOrFileDescriptor,
+        options?:
+            | (ObjectEncodingOptions & {
+                flag?: string | undefined;
+            })
+            | BufferEncoding
+            | null,
+    ): string | NonSharedBuffer;
+    export type WriteFileOptions =
         | (
             & ObjectEncodingOptions
             & Abortable
@@ -3346,7 +3023,7 @@ declare module "node:fs" {
      * @since v0.1.29
      * @param file filename or file descriptor
      */
-    function writeFile(
+    export function writeFile(
         file: PathOrFileDescriptor,
         data: string | NodeJS.ArrayBufferView,
         options: WriteFileOptions,
@@ -3358,12 +3035,12 @@ declare module "node:fs" {
      * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
      * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
      */
-    function writeFile(
+    export function writeFile(
         path: PathOrFileDescriptor,
         data: string | NodeJS.ArrayBufferView,
         callback: NoParamCallback,
     ): void;
-    namespace writeFile {
+    export namespace writeFile {
         /**
          * Asynchronously writes data to a file, replacing the file if it already exists.
          * @param path A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -3392,7 +3069,7 @@ declare module "node:fs" {
      * @since v0.1.29
      * @param file filename or file descriptor
      */
-    function writeFileSync(
+    export function writeFileSync(
         file: PathOrFileDescriptor,
         data: string | NodeJS.ArrayBufferView,
         options?: WriteFileOptions,
@@ -3450,7 +3127,7 @@ declare module "node:fs" {
      * @since v0.6.7
      * @param path filename or file descriptor
      */
-    function appendFile(
+    export function appendFile(
         path: PathOrFileDescriptor,
         data: string | Uint8Array,
         options: WriteFileOptions,
@@ -3462,8 +3139,8 @@ declare module "node:fs" {
      * If a file descriptor is provided, the underlying file will _not_ be closed automatically.
      * @param data The data to write. If something other than a Buffer or Uint8Array is provided, the value is coerced to a string.
      */
-    function appendFile(file: PathOrFileDescriptor, data: string | Uint8Array, callback: NoParamCallback): void;
-    namespace appendFile {
+    export function appendFile(file: PathOrFileDescriptor, data: string | Uint8Array, callback: NoParamCallback): void;
+    export namespace appendFile {
         /**
          * Asynchronously append data to a file, creating the file if it does not exist.
          * @param file A path to a file. If a URL is provided, it must use the `file:` protocol.
@@ -3529,7 +3206,7 @@ declare module "node:fs" {
      * @since v0.6.7
      * @param path filename or file descriptor
      */
-    function appendFileSync(
+    export function appendFileSync(
         path: PathOrFileDescriptor,
         data: string | Uint8Array,
         options?: WriteFileOptions,
@@ -3580,7 +3257,7 @@ declare module "node:fs" {
      * * the file is renamed and then renamed a second time back to its original name
      * @since v0.1.31
      */
-    interface WatchFileOptions {
+    export interface WatchFileOptions {
         bigint?: boolean | undefined;
         persistent?: boolean | undefined;
         interval?: number | undefined;
@@ -3631,7 +3308,7 @@ declare module "node:fs" {
      * * the file is renamed and then renamed a second time back to its original name
      * @since v0.1.31
      */
-    function watchFile(
+    export function watchFile(
         filename: PathLike,
         options:
             | (WatchFileOptions & {
@@ -3640,7 +3317,7 @@ declare module "node:fs" {
             | undefined,
         listener: StatsListener,
     ): StatWatcher;
-    function watchFile(
+    export function watchFile(
         filename: PathLike,
         options:
             | (WatchFileOptions & {
@@ -3653,7 +3330,7 @@ declare module "node:fs" {
      * Watch for changes on `filename`. The callback `listener` will be called each time the file is accessed.
      * @param filename A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
      */
-    function watchFile(filename: PathLike, listener: StatsListener): StatWatcher;
+    export function watchFile(filename: PathLike, listener: StatsListener): StatWatcher;
     /**
      * Stop watching for changes on `filename`. If `listener` is specified, only that
      * particular listener is removed. Otherwise, _all_ listeners are removed,
@@ -3666,25 +3343,23 @@ declare module "node:fs" {
      * @since v0.1.31
      * @param listener Optional, a listener previously attached using `fs.watchFile()`
      */
-    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 {
+    export function unwatchFile(filename: PathLike, listener?: StatsListener): void;
+    export function unwatchFile(filename: PathLike, listener?: BigIntStatsListener): void;
+    export interface WatchOptions extends Abortable {
         encoding?: BufferEncoding | "buffer" | undefined;
         persistent?: boolean | undefined;
         recursive?: boolean | undefined;
-        ignore?: WatchIgnorePredicate | readonly WatchIgnorePredicate[] | undefined;
     }
-    interface WatchOptionsWithBufferEncoding extends WatchOptions {
+    export interface WatchOptionsWithBufferEncoding extends WatchOptions {
         encoding: "buffer";
     }
-    interface WatchOptionsWithStringEncoding extends WatchOptions {
+    export 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;
+    export type WatchEventType = "rename" | "change";
+    export type WatchListener<T> = (event: WatchEventType, filename: T | null) => void;
+    export type StatsListener = (curr: Stats, prev: Stats) => void;
+    export type BigIntStatsListener = (curr: BigIntStats, prev: BigIntStats) => void;
     /**
      * Watch for changes on `filename`, where `filename` is either a file or a
      * directory.
@@ -3705,22 +3380,22 @@ declare module "node:fs" {
      * @since v0.5.10
      * @param listener
      */
-    function watch(
+    export function watch(
         filename: PathLike,
         options?: WatchOptionsWithStringEncoding | BufferEncoding | null,
         listener?: WatchListener<string>,
     ): FSWatcher;
-    function watch(
+    export function watch(
         filename: PathLike,
         options: WatchOptionsWithBufferEncoding | "buffer",
         listener: WatchListener<NonSharedBuffer>,
     ): FSWatcher;
-    function watch(
+    export function watch(
         filename: PathLike,
         options: WatchOptions | BufferEncoding | "buffer" | null,
         listener: WatchListener<string | NonSharedBuffer>,
     ): FSWatcher;
-    function watch(filename: PathLike, listener: WatchListener<string>): FSWatcher;
+    export function watch(filename: PathLike, listener: WatchListener<string>): FSWatcher;
     /**
      * Test whether or not the given path exists by checking with the file system.
      * Then call the `callback` argument with either true or false:
@@ -3850,9 +3525,9 @@ declare module "node:fs" {
      * @since v0.0.2
      * @deprecated Since v1.0.0 - Use {@link stat} or {@link access} instead.
      */
-    function exists(path: PathLike, callback: (exists: boolean) => void): void;
+    export function exists(path: PathLike, callback: (exists: boolean) => void): void;
     /** @deprecated */
-    namespace exists {
+    export namespace exists {
         /**
          * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
          * URL support is _experimental_.
@@ -3876,8 +3551,8 @@ declare module "node:fs" {
      * ```
      * @since v0.1.21
      */
-    function existsSync(path: PathLike): boolean;
-    namespace constants {
+    export function existsSync(path: PathLike): boolean;
+    export namespace constants {
         // File Access Constants
         /** Constant for fs.access(). File is visible to the calling process. */
         const F_OK: number;
@@ -4151,13 +3826,13 @@ declare module "node:fs" {
      * @since v0.11.15
      * @param [mode=fs.constants.F_OK]
      */
-    function access(path: PathLike, mode: number | undefined, callback: NoParamCallback): void;
+    export function access(path: PathLike, mode: number | undefined, callback: NoParamCallback): void;
     /**
      * Asynchronously tests a user's permissions for the file specified by path.
      * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
      */
-    function access(path: PathLike, callback: NoParamCallback): void;
-    namespace access {
+    export function access(path: PathLike, callback: NoParamCallback): void;
+    export namespace access {
         /**
          * Asynchronously tests a user's permissions for the file specified by path.
          * @param path A path to a file or directory. If a URL is provided, it must use the `file:` protocol.
@@ -4188,11 +3863,11 @@ declare module "node:fs" {
      * @since v0.11.15
      * @param [mode=fs.constants.F_OK]
      */
-    function accessSync(path: PathLike, mode?: number): void;
+    export function accessSync(path: PathLike, mode?: number): void;
     interface StreamOptions {
         flags?: string | undefined;
         encoding?: BufferEncoding | undefined;
-        fd?: number | FileHandle | undefined;
+        fd?: number | promises.FileHandle | undefined;
         mode?: number | undefined;
         autoClose?: boolean | undefined;
         emitClose?: boolean | undefined;
@@ -4280,7 +3955,7 @@ declare module "node:fs" {
      * If `options` is a string, then it specifies the encoding.
      * @since v0.1.31
      */
-    function createReadStream(path: PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
+    export function createReadStream(path: PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
     /**
      * `options` may also include a `start` option to allow writing data at some
      * position past the beginning of the file, allowed values are in the
@@ -4308,7 +3983,7 @@ declare module "node:fs" {
      * If `options` is a string, then it specifies the encoding.
      * @since v0.1.31
      */
-    function createWriteStream(path: PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
+    export function createWriteStream(path: PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
     /**
      * Forces all currently queued I/O operations associated with the file to the
      * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. No arguments other
@@ -4316,8 +3991,8 @@ declare module "node:fs" {
      * exception are given to the completion callback.
      * @since v0.1.96
      */
-    function fdatasync(fd: number, callback: NoParamCallback): void;
-    namespace fdatasync {
+    export function fdatasync(fd: number, callback: NoParamCallback): void;
+    export namespace fdatasync {
         /**
          * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
          * @param fd A file descriptor.
@@ -4329,7 +4004,7 @@ declare module "node:fs" {
      * operating system's synchronized I/O completion state. Refer to the POSIX [`fdatasync(2)`](http://man7.org/linux/man-pages/man2/fdatasync.2.html) documentation for details. Returns `undefined`.
      * @since v0.1.96
      */
-    function fdatasyncSync(fd: number): void;
+    export function fdatasyncSync(fd: number): void;
     /**
      * Asynchronously copies `src` to `dest`. By default, `dest` is overwritten if it
      * already exists. No arguments other than a possible exception are given to the
@@ -4369,9 +4044,9 @@ declare module "node:fs" {
      * @param dest destination filename of the copy operation
      * @param [mode=0] modifiers for copy operation.
      */
-    function copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
-    function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
-    namespace copyFile {
+    export function copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
+    export function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
+    export namespace copyFile {
         function __promisify__(src: PathLike, dst: PathLike, mode?: number): Promise<void>;
     }
     /**
@@ -4408,7 +4083,7 @@ declare module "node:fs" {
      * @param dest destination filename of the copy operation
      * @param [mode=0] modifiers for copy operation.
      */
-    function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
+    export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
     /**
      * Write an array of `ArrayBufferView`s to the file specified by `fd` using `writev()`.
      *
@@ -4429,12 +4104,12 @@ declare module "node:fs" {
      * @since v12.9.0
      * @param [position='null']
      */
-    function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
+    export 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[]>(
+    export function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
         fd: number,
         buffers: TBuffers,
         position: number | null,
@@ -4442,11 +4117,11 @@ declare module "node:fs" {
     ): void;
     // Providing a default type parameter doesn't provide true BC for userland consumers, but at least suppresses TS2314
     // TODO: remove default in future major version
-    interface WriteVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
+    export interface WriteVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
         bytesWritten: number;
         buffers: T;
     }
-    namespace writev {
+    export namespace writev {
         function __promisify__<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
             fd: number,
             buffers: TBuffers,
@@ -4460,7 +4135,7 @@ declare module "node:fs" {
      * @param [position='null']
      * @return The number of bytes written.
      */
-    function writevSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
+    export function writevSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
     /**
      * Read from a file specified by `fd` and write to an array of `ArrayBufferView`s
      * using `readv()`.
@@ -4476,12 +4151,12 @@ declare module "node:fs" {
      * @since v13.13.0, v12.17.0
      * @param [position='null']
      */
-    function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
+    export 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[]>(
+    export function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
         fd: number,
         buffers: TBuffers,
         position: number | null,
@@ -4489,11 +4164,11 @@ declare module "node:fs" {
     ): void;
     // Providing a default type parameter doesn't provide true BC for userland consumers, but at least suppresses TS2314
     // TODO: remove default in future major version
-    interface ReadVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
+    export interface ReadVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
         bytesRead: number;
         buffers: T;
     }
-    namespace readv {
+    export namespace readv {
         function __promisify__<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
             fd: number,
             buffers: TBuffers,
@@ -4507,9 +4182,9 @@ declare module "node:fs" {
      * @param [position='null']
      * @return The number of bytes read.
      */
-    function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
+    export function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
 
-    interface OpenAsBlobOptions {
+    export interface OpenAsBlobOptions {
         /**
          * An optional mime type for the blob.
          *
@@ -4535,9 +4210,9 @@ declare module "node:fs" {
      * ```
      * @since v19.8.0
      */
-    function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
+    export function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
 
-    interface OpenDirOptions {
+    export interface OpenDirOptions {
         /**
          * @default 'utf8'
          */
@@ -4564,7 +4239,7 @@ declare module "node:fs" {
      * directory and subsequent read operations.
      * @since v12.12.0
      */
-    function opendirSync(path: PathLike, options?: OpenDirOptions): Dir;
+    export function opendirSync(path: PathLike, options?: OpenDirOptions): Dir;
     /**
      * Asynchronously open a directory. See the POSIX [`opendir(3)`](http://man7.org/linux/man-pages/man3/opendir.3.html) documentation for
      * more details.
@@ -4576,31 +4251,30 @@ declare module "node:fs" {
      * directory and subsequent read operations.
      * @since v12.12.0
      */
-    function opendir(path: PathLike, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
-    function opendir(
+    export function opendir(path: PathLike, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
+    export function opendir(
         path: PathLike,
         options: OpenDirOptions,
         cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
     ): void;
-    namespace opendir {
+    export namespace opendir {
         function __promisify__(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
     }
-    interface BigIntStats extends StatsBase<bigint> {
+    export interface BigIntStats extends StatsBase<bigint> {
         atimeNs: bigint;
         mtimeNs: bigint;
         ctimeNs: bigint;
         birthtimeNs: bigint;
     }
-    interface BigIntOptions {
+    export interface BigIntOptions {
         bigint: true;
     }
-    interface StatOptions {
-        // TODO: add signal option once we sort its behavior out upstream
+    export interface StatOptions {
         bigint?: boolean | undefined;
+    }
+    export interface StatSyncOptions extends StatOptions {
         throwIfNoEntry?: boolean | undefined;
     }
-    /** @deprecated This orphaned interface will be removed in a future version. Use `StatOptions` instead. */
-    interface StatSyncOptions extends StatOptions {}
     interface CopyOptionsBase {
         /**
          * Dereference symlinks
@@ -4641,14 +4315,14 @@ declare module "node:fs" {
          */
         verbatimSymlinks?: boolean | undefined;
     }
-    interface CopyOptions extends CopyOptionsBase {
+    export interface CopyOptions extends CopyOptionsBase {
         /**
          * Function to filter copied files/directories. Return
          * `true` to copy the item, `false` to ignore it.
          */
         filter?: ((source: string, destination: string) => boolean | Promise<boolean>) | undefined;
     }
-    interface CopySyncOptions extends CopyOptionsBase {
+    export interface CopySyncOptions extends CopyOptionsBase {
         /**
          * Function to filter copied files/directories. Return
          * `true` to copy the item, `false` to ignore it.
@@ -4666,12 +4340,12 @@ declare module "node:fs" {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    function cp(
+    export function cp(
         source: string | URL,
         destination: string | URL,
         callback: (err: NodeJS.ErrnoException | null) => void,
     ): void;
-    function cp(
+    export function cp(
         source: string | URL,
         destination: string | URL,
         opts: CopyOptions,
@@ -4688,49 +4362,41 @@ declare module "node:fs" {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
-    interface GlobOptions<T extends Dirent | string = Dirent | string> {
+    export function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
+
+    interface _GlobOptions<T extends Dirent | string> {
         /**
          * Current working directory.
          * @default process.cwd()
          */
         cwd?: string | URL | undefined;
-        /**
-         * Function to filter out files/directories or a
-         * list of glob patterns to be excluded. If a function is provided, return
-         * `true` to exclude the item, `false` to include it.
-         * If a string array is provided, each string should be a glob pattern that
-         * specifies paths to exclude. Note: Negation patterns (e.g., '!foo.js') are
-         * not supported.
-         * @default undefined
-         */
-        exclude?: ((fileName: T) => boolean) | readonly string[] | undefined;
-        /**
-         * When `true`, symbolic links to directories are
-         * followed while expanding `**` patterns.
-         * @default false
-         */
-        followSymlinks?: boolean | undefined;
         /**
          * `true` if the glob should return paths as `Dirent`s, `false` otherwise.
          * @default false
          * @since v22.2.0
          */
         withFileTypes?: boolean | undefined;
+        /**
+         * Function to filter out files/directories or a
+         * list of glob patterns to be excluded. If a function is provided, return
+         * `true` to exclude the item, `false` to include it. If a string array is
+         * provided, each string should be a glob pattern that specifies paths to exclude.
+         * Note: Negation patterns (e.g., '!foo.js') are not supported.
+         * @default undefined
+         */
+        exclude?: ((fileName: T) => boolean) | readonly string[] | undefined;
     }
-    interface GlobOptionsWithFileTypes extends GlobOptions<Dirent> {
+    export interface GlobOptions extends _GlobOptions<Dirent | string> {}
+    export interface GlobOptionsWithFileTypes extends _GlobOptions<Dirent> {
         withFileTypes: true;
     }
-    interface GlobOptionsWithoutFileTypes extends GlobOptions<string> {
+    export interface GlobOptionsWithoutFileTypes extends _GlobOptions<string> {
         withFileTypes?: false | undefined;
     }
 
     /**
      * Retrieves the files matching the specified pattern.
      *
-     * When `followSymlinks` is enabled, detected symbolic link cycles are not
-     * traversed recursively.
-     *
      * ```js
      * import { glob } from 'node:fs';
      *
@@ -4741,11 +4407,11 @@ declare module "node:fs" {
      * ```
      * @since v22.0.0
      */
-    function glob(
+    export function glob(
         pattern: string | readonly string[],
         callback: (err: NodeJS.ErrnoException | null, matches: string[]) => void,
     ): void;
-    function glob(
+    export function glob(
         pattern: string | readonly string[],
         options: GlobOptionsWithFileTypes,
         callback: (
@@ -4753,7 +4419,7 @@ declare module "node:fs" {
             matches: Dirent[],
         ) => void,
     ): void;
-    function glob(
+    export function glob(
         pattern: string | readonly string[],
         options: GlobOptionsWithoutFileTypes,
         callback: (
@@ -4761,7 +4427,7 @@ declare module "node:fs" {
             matches: string[],
         ) => void,
     ): void;
-    function glob(
+    export function glob(
         pattern: string | readonly string[],
         options: GlobOptions,
         callback: (
@@ -4770,9 +4436,6 @@ declare module "node:fs" {
         ) => void,
     ): void;
     /**
-     * When `followSymlinks` is enabled, detected symbolic link cycles are not
-     * traversed recursively.
-     *
      * ```js
      * import { globSync } from 'node:fs';
      *
@@ -4781,23 +4444,20 @@ declare module "node:fs" {
      * @since v22.0.0
      * @returns paths of files that match the pattern.
      */
-    function globSync(pattern: string | readonly string[]): string[];
-    function globSync(
+    export function globSync(pattern: string | readonly string[]): string[];
+    export function globSync(
         pattern: string | readonly string[],
         options: GlobOptionsWithFileTypes,
     ): Dirent[];
-    function globSync(
+    export function globSync(
         pattern: string | readonly string[],
         options: GlobOptionsWithoutFileTypes,
     ): string[];
-    function globSync(
+    export 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";
+    export * from "fs";
 }