@psnext/slingcli 3.3.20260911-1 → 3.3.20260914-1

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

@@ -1,49 +1,28 @@
-/**
- * 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";
+declare module "node:fs" {
+    import { BufferView, NonSharedBuffer } from "node:buffer";
+    import { Abortable, EventEmitter, InternalEventEmitter } from "node:events";
+    import { FileHandle } from "node:fs/promises";
     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".
      */
-    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 =
+    type PathLike = string | Buffer | URL;
+    type PathOrFileDescriptor = PathLike | number;
+    type TimeLike = string | number | Date;
+    type NoParamCallback = (err: NodeJS.ErrnoException | null) => void;
+    type BufferEncodingOption =
         | "buffer"
         | {
             encoding: "buffer";
         };
-    export interface ObjectEncodingOptions {
+    interface ObjectEncodingOptions {
         encoding?: BufferEncoding | null | undefined;
     }
-    export type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
-    export type OpenMode = number | string;
-    export type Mode = number | string;
-    export interface StatsBase<T> {
+    type EncodingOption = ObjectEncodingOptions | BufferEncoding | undefined | null;
+    type OpenMode = number | string;
+    type Mode = number | string;
+    interface StatsBase<T> {
         isFile(): boolean;
         isDirectory(): boolean;
         isBlockDevice(): boolean;
@@ -69,8 +48,15 @@ declare module "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;
     }
-    export interface Stats extends StatsBase<number> {}
+    interface Stats extends StatsBase<number> {}
     /**
      * A `fs.Stats` object provides information about a file.
      *
@@ -131,10 +117,10 @@ declare module "fs" {
      * ```
      * @since v0.1.21
      */
-    export class Stats {
+    class Stats {
         private constructor();
     }
-    export interface StatsFsBase<T> {
+    interface StatsFsBase<T> {
         /** Type of file system. */
         type: T;
         /**  Optimal transfer block size. */
@@ -147,10 +133,12 @@ declare module "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;
     }
-    export interface StatsFs extends StatsFsBase<number> {}
+    interface StatsFs extends StatsFsBase<number> {}
     /**
      * Provides information about a mounted file system.
      *
@@ -185,9 +173,9 @@ declare module "fs" {
      * ```
      * @since v19.6.0, v18.15.0
      */
-    export class StatsFs {}
-    export interface BigIntStatsFs extends StatsFsBase<bigint> {}
-    export interface StatFsOptions {
+    class StatsFs {}
+    interface BigIntStatsFs extends StatsFsBase<bigint> {}
+    interface StatFsOptions {
         bigint?: boolean | undefined;
     }
     /**
@@ -199,7 +187,7 @@ declare module "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
      */
-    export class Dirent<Name extends string | Buffer = string> {
+    class Dirent<Name extends string | Buffer = string> {
         /**
          * Returns `true` if the `fs.Dirent` object describes a regular file.
          * @since v10.10.0
@@ -248,12 +236,6 @@ declare module "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.
@@ -276,7 +258,7 @@ declare module "fs" {
      * closed after the iterator exits.
      * @since v12.12.0
      */
-    export class Dir implements AsyncIterable<Dirent> {
+    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
@@ -332,15 +314,13 @@ declare module "fs" {
         /**
          * Calls `dir.close()` if the directory handle is open, and returns a promise that
          * fulfills when disposal is complete.
-         * @since v22.17.0
-         * @experimental
+         * @since v24.1.0
          */
         [Symbol.asyncDispose](): Promise<void>;
         /**
          * Calls `dir.closeSync()` if the directory handle is open, and returns
          * `undefined`.
-         * @since v22.17.0
-         * @experimental
+         * @since v24.1.0
          */
         [Symbol.dispose](): void;
     }
@@ -350,7 +330,7 @@ declare module "fs" {
      * Extends `EventEmitter`
      * A successful call to {@link watchFile} method will return a new fs.StatWatcher object.
      */
-    export interface StatWatcher extends EventEmitter {
+    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.
@@ -371,7 +351,12 @@ declare module "fs" {
          */
         unref(): this;
     }
-    export interface FSWatcher extends EventEmitter {
+    interface FSWatcherEventMap {
+        "change": [eventType: string, filename: string | NonSharedBuffer];
+        "close": [];
+        "error": [error: Error];
+    }
+    interface FSWatcher extends InternalEventEmitter<FSWatcherEventMap> {
         /**
          * Stop watching for changes on the given `fs.FSWatcher`. Once stopped, the `fs.FSWatcher` object is no longer usable.
          * @since v0.5.8
@@ -396,44 +381,19 @@ declare module "fs" {
          * @since v14.3.0, v12.20.0
          */
         unref(): this;
-        /**
-         * 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;
+    }
+    interface ReadStreamEventMap extends stream.ReadableEventMap {
+        "close": [];
+        "data": [chunk: string | NonSharedBuffer];
+        "open": [fd: number];
+        "ready": [];
     }
     /**
-     * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function.
+     * Instances of `fs.ReadStream` cannot be constructed directly. They are created and
+     * returned using the `fs.createReadStream()` function.
      * @since v0.1.93
      */
-    export class ReadStream extends stream.Readable {
+    class ReadStream extends stream.Readable {
         close(callback?: (err?: NodeJS.ErrnoException | null) => void): void;
         /**
          * The number of bytes that have been read so far.
@@ -453,60 +413,251 @@ declare module "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;
         /**
-         * events.EventEmitter
-         *   1. open
-         *   2. close
-         *   3. ready
+         * Calls flush every `periodicFlush` milliseconds.
          */
-        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;
+        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];
     }
-
-    /**
-     * 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.
-     */
-    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.
+     * 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
      */
-    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;
+    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": [];
+    }
     /**
-     * * Extends `stream.Writable`
-     *
-     * Instances of `fs.WriteStream` are created and returned using the {@link createWriteStream} function.
+     * Instances of `fs.WriteStream` cannot be constructed directly. They are created and
+     * returned using the `fs.createWriteStream()` function.
      * @since v0.1.93
      */
-    export class WriteStream extends stream.Writable {
+    class WriteStream extends stream.Writable {
         /**
          * Closes `writeStream`. Optionally accepts a
          * callback that will be executed once the `writeStream`is closed.
@@ -532,17 +683,57 @@ declare module "fs" {
          * @since v11.2.0
          */
         pending: boolean;
-        /**
-         * 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;
+        // #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
     }
     /**
      * Asynchronously rename file at `oldPath` to the pathname provided
@@ -563,8 +754,8 @@ declare module "fs" {
      * ```
      * @since v0.0.2
      */
-    export function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
-    export namespace rename {
+    function rename(oldPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
+    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.
@@ -580,7 +771,7 @@ declare module "fs" {
      * See the POSIX [`rename(2)`](http://man7.org/linux/man-pages/man2/rename.2.html) documentation for more details.
      * @since v0.1.21
      */
-    export function renameSync(oldPath: PathLike, newPath: PathLike): void;
+    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
@@ -602,13 +793,13 @@ declare module "fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    export function truncate(path: PathLike, len: number | undefined, callback: NoParamCallback): void;
+    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.
      */
-    export function truncate(path: PathLike, callback: NoParamCallback): void;
-    export namespace truncate {
+    function truncate(path: PathLike, callback: NoParamCallback): void;
+    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.
@@ -625,7 +816,7 @@ declare module "fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    export function truncateSync(path: PathLike, len?: number): void;
+    function truncateSync(path: PathLike, len?: number): void;
     /**
      * Truncates the file descriptor. No arguments other than a possible exception are
      * given to the completion callback.
@@ -669,13 +860,13 @@ declare module "fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    export function ftruncate(fd: number, len: number | undefined, callback: NoParamCallback): void;
+    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.
      */
-    export function ftruncate(fd: number, callback: NoParamCallback): void;
-    export namespace ftruncate {
+    function ftruncate(fd: number, callback: NoParamCallback): void;
+    namespace ftruncate {
         /**
          * Asynchronous ftruncate(2) - Truncate a file to a specified length.
          * @param fd A file descriptor.
@@ -691,7 +882,7 @@ declare module "fs" {
      * @since v0.8.6
      * @param [len=0]
      */
-    export function ftruncateSync(fd: number, len?: number): void;
+    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.
@@ -699,8 +890,8 @@ declare module "fs" {
      * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail.
      * @since v0.1.97
      */
-    export function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
-    export namespace chown {
+    function chown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
+    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.
@@ -714,7 +905,7 @@ declare module "fs" {
      * See the POSIX [`chown(2)`](http://man7.org/linux/man-pages/man2/chown.2.html) documentation for more detail.
      * @since v0.1.97
      */
-    export function chownSync(path: PathLike, uid: number, gid: number): void;
+    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.
@@ -722,8 +913,8 @@ declare module "fs" {
      * See the POSIX [`fchown(2)`](http://man7.org/linux/man-pages/man2/fchown.2.html) documentation for more detail.
      * @since v0.4.7
      */
-    export function fchown(fd: number, uid: number, gid: number, callback: NoParamCallback): void;
-    export namespace fchown {
+    function fchown(fd: number, uid: number, gid: number, callback: NoParamCallback): void;
+    namespace fchown {
         /**
          * Asynchronous fchown(2) - Change ownership of a file.
          * @param fd A file descriptor.
@@ -738,15 +929,15 @@ declare module "fs" {
      * @param uid The file's new owner's user id.
      * @param gid The file's new group's group id.
      */
-    export function fchownSync(fd: number, uid: number, gid: number): void;
+    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.
      */
-    export function lchown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
-    export namespace lchown {
+    function lchown(path: PathLike, uid: number, gid: number, callback: NoParamCallback): void;
+    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.
@@ -760,7 +951,7 @@ declare module "fs" {
      * @param uid The file's new owner's user id.
      * @param gid The file's new group's group id.
      */
-    export function lchownSync(path: PathLike, uid: number, gid: number): void;
+    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
@@ -770,8 +961,8 @@ declare module "fs" {
      * callback.
      * @since v14.5.0, v12.19.0
      */
-    export function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
-    export namespace lutimes {
+    function lutimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    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
@@ -788,7 +979,7 @@ declare module "fs" {
      * the operation fails. This is the synchronous version of {@link lutimes}.
      * @since v14.5.0, v12.19.0
      */
-    export function lutimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+    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.
@@ -805,8 +996,8 @@ declare module "fs" {
      * ```
      * @since v0.1.30
      */
-    export function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
-    export namespace chmod {
+    function chmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
+    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.
@@ -821,7 +1012,7 @@ declare module "fs" {
      * See the POSIX [`chmod(2)`](http://man7.org/linux/man-pages/man2/chmod.2.html) documentation for more detail.
      * @since v0.6.7
      */
-    export function chmodSync(path: PathLike, mode: Mode): void;
+    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.
@@ -829,8 +1020,8 @@ declare module "fs" {
      * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail.
      * @since v0.4.7
      */
-    export function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void;
-    export namespace fchmod {
+    function fchmod(fd: number, mode: Mode, callback: NoParamCallback): void;
+    namespace fchmod {
         /**
          * Asynchronous fchmod(2) - Change permissions of a file.
          * @param fd A file descriptor.
@@ -844,7 +1035,7 @@ declare module "fs" {
      * See the POSIX [`fchmod(2)`](http://man7.org/linux/man-pages/man2/fchmod.2.html) documentation for more detail.
      * @since v0.4.7
      */
-    export function fchmodSync(fd: number, mode: Mode): void;
+    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.
@@ -854,9 +1045,9 @@ declare module "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
      */
-    export function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
+    function lchmod(path: PathLike, mode: Mode, callback: NoParamCallback): void;
     /** @deprecated */
-    export namespace lchmod {
+    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.
@@ -872,7 +1063,7 @@ declare module "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
      */
-    export function lchmodSync(path: PathLike, mode: Mode): void;
+    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.
      *
@@ -958,48 +1149,98 @@ declare module "fs" {
      * ```
      * @since v0.0.2
      */
-    export function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-    export function stat(
+    function stat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function stat(
         path: PathLike,
         options:
             | (StatOptions & {
                 bigint?: false | undefined;
+                throwIfNoEntry?: true | undefined;
             })
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
     ): void;
-    export function stat(
+    function stat(
         path: PathLike,
         options: StatOptions & {
             bigint: true;
+            throwIfNoEntry?: true | undefined;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void,
     ): void;
-    export function stat(
+    function stat(
         path: PathLike,
-        options: StatOptions | undefined,
+        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;
-    export namespace stat {
+    function stat(
+        path: PathLike,
+        options: StatOptions | undefined,
+        callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats | undefined) => void,
+    ): void;
+    namespace stat {
+        // TODO: aliased promisify signatures
         /**
          * 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): Promise<Stats | 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>;
     }
-    export interface StatSyncFn extends Function {
+    /** @deprecated This orphaned interface will be removed in a future version. */
+    interface StatSyncFn extends Function {
         (path: PathLike, options?: undefined): Stats;
         (
             path: PathLike,
@@ -1040,15 +1281,50 @@ declare module "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.
      */
-    export const statSync: StatSyncFn;
+    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;
     /**
      * 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
      */
-    export function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-    export function fstat(
+    function fstat(fd: number, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function fstat(
         fd: number,
         options:
             | (StatOptions & {
@@ -1057,19 +1333,19 @@ declare module "fs" {
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
     ): void;
-    export function fstat(
+    function fstat(
         fd: number,
         options: StatOptions & {
             bigint: true;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void,
     ): void;
-    export function fstat(
+    function fstat(
         fd: number,
         options: StatOptions | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void,
     ): void;
-    export namespace fstat {
+    namespace fstat {
         /**
          * Asynchronous fstat(2) - Get file status.
          * @param fd A file descriptor.
@@ -1094,19 +1370,19 @@ declare module "fs" {
      * See the POSIX [`fstat(2)`](http://man7.org/linux/man-pages/man2/fstat.2.html) documentation for more detail.
      * @since v0.1.95
      */
-    export function fstatSync(
+    function fstatSync(
         fd: number,
         options?: StatOptions & {
             bigint?: false | undefined;
         },
     ): Stats;
-    export function fstatSync(
+    function fstatSync(
         fd: number,
         options: StatOptions & {
             bigint: true;
         },
     ): BigIntStats;
-    export function fstatSync(fd: number, options?: StatOptions): Stats | BigIntStats;
+    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
@@ -1115,8 +1391,8 @@ declare module "fs" {
      * See the POSIX [`lstat(2)`](http://man7.org/linux/man-pages/man2/lstat.2.html) documentation for more details.
      * @since v0.1.30
      */
-    export function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
-    export function lstat(
+    function lstat(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void): void;
+    function lstat(
         path: PathLike,
         options:
             | (StatOptions & {
@@ -1125,19 +1401,19 @@ declare module "fs" {
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats) => void,
     ): void;
-    export function lstat(
+    function lstat(
         path: PathLike,
         options: StatOptions & {
             bigint: true;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStats) => void,
     ): void;
-    export function lstat(
+    function lstat(
         path: PathLike,
         options: StatOptions | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: Stats | BigIntStats) => void,
     ): void;
-    export namespace lstat {
+    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.
@@ -1164,8 +1440,8 @@ declare module "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.
      */
-    export function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
-    export function statfs(
+    function statfs(path: PathLike, callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void): void;
+    function statfs(
         path: PathLike,
         options:
             | (StatFsOptions & {
@@ -1174,19 +1450,19 @@ declare module "fs" {
             | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: StatsFs) => void,
     ): void;
-    export function statfs(
+    function statfs(
         path: PathLike,
         options: StatFsOptions & {
             bigint: true;
         },
         callback: (err: NodeJS.ErrnoException | null, stats: BigIntStatsFs) => void,
     ): void;
-    export function statfs(
+    function statfs(
         path: PathLike,
         options: StatFsOptions | undefined,
         callback: (err: NodeJS.ErrnoException | null, stats: StatsFs | BigIntStatsFs) => void,
     ): void;
-    export namespace statfs {
+    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.
@@ -1213,32 +1489,67 @@ declare module "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.
      */
-    export function statfsSync(
+    function statfsSync(
         path: PathLike,
         options?: StatFsOptions & {
             bigint?: false | undefined;
         },
     ): StatsFs;
-    export function statfsSync(
+    function statfsSync(
         path: PathLike,
         options: StatFsOptions & {
             bigint: true;
         },
     ): BigIntStatsFs;
-    export function statfsSync(path: PathLike, options?: StatFsOptions): StatsFs | BigIntStatsFs;
+    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.
      */
-    export const lstatSync: StatSyncFn;
+    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;
     /**
      * 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
      */
-    export function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
-    export namespace link {
+    function link(existingPath: PathLike, newPath: PathLike, callback: NoParamCallback): void;
+    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.
@@ -1250,7 +1561,7 @@ declare module "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
      */
-    export function linkSync(existingPath: PathLike, newPath: PathLike): void;
+    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.
@@ -1284,7 +1595,7 @@ declare module "fs" {
      * @since v0.1.31
      * @param [type='null']
      */
-    export function symlink(
+    function symlink(
         target: PathLike,
         path: PathLike,
         type: symlink.Type | undefined | null,
@@ -1295,8 +1606,8 @@ declare module "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.
      */
-    export function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
-    export namespace symlink {
+    function symlink(target: PathLike, path: PathLike, callback: NoParamCallback): void;
+    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.
@@ -1315,7 +1626,7 @@ declare module "fs" {
      * @since v0.1.31
      * @param [type='null']
      */
-    export function symlinkSync(target: PathLike, path: PathLike, type?: symlink.Type | null): void;
+    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)`.
@@ -1328,7 +1639,7 @@ declare module "fs" {
      * the link path returned will be passed as a `Buffer` object.
      * @since v0.1.31
      */
-    export function readlink(
+    function readlink(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, linkString: string) => void,
@@ -1338,7 +1649,7 @@ declare module "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.
      */
-    export function readlink(
+    function readlink(
         path: PathLike,
         options: BufferEncodingOption,
         callback: (err: NodeJS.ErrnoException | null, linkString: NonSharedBuffer) => void,
@@ -1348,7 +1659,7 @@ declare module "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.
      */
-    export function readlink(
+    function readlink(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, linkString: string | NonSharedBuffer) => void,
@@ -1357,11 +1668,11 @@ declare module "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.
      */
-    export function readlink(
+    function readlink(
         path: PathLike,
         callback: (err: NodeJS.ErrnoException | null, linkString: string) => void,
     ): void;
-    export namespace readlink {
+    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.
@@ -1392,19 +1703,19 @@ declare module "fs" {
      * the link path returned will be passed as a `Buffer` object.
      * @since v0.1.31
      */
-    export function readlinkSync(path: PathLike, options?: EncodingOption): string;
+    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.
      */
-    export function readlinkSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+    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.
      */
-    export function readlinkSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    function readlinkSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
     /**
      * Asynchronously computes the canonical pathname by resolving `.`, `..`, and
      * symbolic links.
@@ -1431,7 +1742,7 @@ declare module "fs" {
      * dependent name for that object.
      * @since v0.1.31
      */
-    export function realpath(
+    function realpath(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void,
@@ -1441,7 +1752,7 @@ declare module "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.
      */
-    export function realpath(
+    function realpath(
         path: PathLike,
         options: BufferEncodingOption,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: NonSharedBuffer) => void,
@@ -1451,7 +1762,7 @@ declare module "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.
      */
-    export function realpath(
+    function realpath(
         path: PathLike,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: string | NonSharedBuffer) => void,
@@ -1460,11 +1771,11 @@ declare module "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.
      */
-    export function realpath(
+    function realpath(
         path: PathLike,
         callback: (err: NodeJS.ErrnoException | null, resolvedPath: string) => void,
     ): void;
-    export namespace realpath {
+    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.
@@ -1527,20 +1838,20 @@ declare module "fs" {
      * this API: {@link realpath}.
      * @since v0.1.31
      */
-    export function realpathSync(path: PathLike, options?: EncodingOption): string;
+    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.
      */
-    export function realpathSync(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
+    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.
      */
-    export function realpathSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
-    export namespace realpathSync {
+    function realpathSync(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
+    namespace realpathSync {
         function native(path: PathLike, options?: EncodingOption): string;
         function native(path: PathLike, options: BufferEncodingOption): NonSharedBuffer;
         function native(path: PathLike, options?: EncodingOption): string | NonSharedBuffer;
@@ -1564,8 +1875,8 @@ declare module "fs" {
      * See the POSIX [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html) documentation for more details.
      * @since v0.0.2
      */
-    export function unlink(path: PathLike, callback: NoParamCallback): void;
-    export namespace unlink {
+    function unlink(path: PathLike, callback: NoParamCallback): void;
+    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.
@@ -1576,34 +1887,10 @@ declare module "fs" {
      * Synchronous [`unlink(2)`](http://man7.org/linux/man-pages/man2/unlink.2.html). Returns `undefined`.
      * @since v0.1.21
      */
-    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;
-    }
+    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 {}
     /**
      * 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.
@@ -1614,14 +1901,13 @@ declare module "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
      */
-    export function rmdir(path: PathLike, callback: NoParamCallback): void;
-    export function rmdir(path: PathLike, options: RmDirOptions, callback: NoParamCallback): void;
-    export namespace rmdir {
+    function rmdir(path: PathLike, callback: NoParamCallback): void;
+    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, options?: RmDirOptions): Promise<void>;
+        function __promisify__(path: PathLike): Promise<void>;
     }
     /**
      * Synchronous [`rmdir(2)`](http://man7.org/linux/man-pages/man2/rmdir.2.html). Returns `undefined`.
@@ -1632,8 +1918,8 @@ declare module "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
      */
-    export function rmdirSync(path: PathLike, options?: RmDirOptions): void;
-    export interface RmOptions {
+    function rmdirSync(path: PathLike): void;
+    interface RmOptions {
         /**
          * When `true`, exceptions will be ignored if `path` does not exist.
          * @default false
@@ -1666,9 +1952,9 @@ declare module "fs" {
      * completion callback.
      * @since v14.14.0
      */
-    export function rm(path: PathLike, callback: NoParamCallback): void;
-    export function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
-    export namespace rm {
+    function rm(path: PathLike, callback: NoParamCallback): void;
+    function rm(path: PathLike, options: RmOptions, callback: NoParamCallback): void;
+    namespace rm {
         /**
          * Asynchronously removes files and directories (modeled on the standard POSIX `rm` utility).
          */
@@ -1678,8 +1964,8 @@ declare module "fs" {
      * Synchronously removes files and directories (modeled on the standard POSIX `rm` utility). Returns `undefined`.
      * @since v14.14.0
      */
-    export function rmSync(path: PathLike, options?: RmOptions): void;
-    export interface MakeDirectoryOptions {
+    function rmSync(path: PathLike, options?: RmOptions): void;
+    interface MakeDirectoryOptions {
         /**
          * Indicates whether parent folders should be created.
          * If a folder was created, the path to the first created folder will be returned.
@@ -1728,7 +2014,7 @@ declare module "fs" {
      * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
      * @since v0.1.8
      */
-    export function mkdir(
+    function mkdir(
         path: PathLike,
         options: MakeDirectoryOptions & {
             recursive: true;
@@ -1741,7 +2027,7 @@ declare module "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`.
      */
-    export function mkdir(
+    function mkdir(
         path: PathLike,
         options:
             | Mode
@@ -1758,7 +2044,7 @@ declare module "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`.
      */
-    export function mkdir(
+    function mkdir(
         path: PathLike,
         options: Mode | MakeDirectoryOptions | null | undefined,
         callback: (err: NodeJS.ErrnoException | null, path?: string) => void,
@@ -1767,8 +2053,8 @@ declare module "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.
      */
-    export function mkdir(path: PathLike, callback: NoParamCallback): void;
-    export namespace mkdir {
+    function mkdir(path: PathLike, callback: NoParamCallback): void;
+    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.
@@ -1814,7 +2100,7 @@ declare module "fs" {
      * See the POSIX [`mkdir(2)`](http://man7.org/linux/man-pages/man2/mkdir.2.html) documentation for more details.
      * @since v0.1.21
      */
-    export function mkdirSync(
+    function mkdirSync(
         path: PathLike,
         options: MakeDirectoryOptions & {
             recursive: true;
@@ -1826,7 +2112,7 @@ declare module "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`.
      */
-    export function mkdirSync(
+    function mkdirSync(
         path: PathLike,
         options?:
             | Mode
@@ -1841,7 +2127,7 @@ declare module "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`.
      */
-    export function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined;
+    function mkdirSync(path: PathLike, options?: Mode | MakeDirectoryOptions | null): string | undefined;
     /**
      * Creates a unique temporary directory.
      *
@@ -1901,7 +2187,7 @@ declare module "fs" {
      * ```
      * @since v5.10.0
      */
-    export function mkdtemp(
+    function mkdtemp(
         prefix: string,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, folder: string) => void,
@@ -1911,7 +2197,7 @@ declare module "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.
      */
-    export function mkdtemp(
+    function mkdtemp(
         prefix: string,
         options: BufferEncodingOption,
         callback: (err: NodeJS.ErrnoException | null, folder: NonSharedBuffer) => void,
@@ -1921,7 +2207,7 @@ declare module "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.
      */
-    export function mkdtemp(
+    function mkdtemp(
         prefix: string,
         options: EncodingOption,
         callback: (err: NodeJS.ErrnoException | null, folder: string | NonSharedBuffer) => void,
@@ -1930,11 +2216,11 @@ declare module "fs" {
      * Asynchronously creates a unique temporary directory.
      * Generates six random characters to be appended behind a required prefix to create a unique temporary directory.
      */
-    export function mkdtemp(
+    function mkdtemp(
         prefix: string,
         callback: (err: NodeJS.ErrnoException | null, folder: string) => void,
     ): void;
-    export namespace mkdtemp {
+    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.
@@ -1964,19 +2250,52 @@ declare module "fs" {
      * object with an `encoding` property specifying the character encoding to use.
      * @since v5.10.0
      */
-    export function mkdtempSync(prefix: string, options?: EncodingOption): string;
+    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.
      */
-    export function mkdtempSync(prefix: string, options: BufferEncodingOption): NonSharedBuffer;
+    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.
      */
-    export function mkdtempSync(prefix: string, options?: EncodingOption): string | NonSharedBuffer;
+    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;
     /**
      * 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 `'..'`.
      *
@@ -1990,7 +2309,7 @@ declare module "fs" {
      * If `options.withFileTypes` is set to `true`, the `files` array will contain `fs.Dirent` objects.
      * @since v0.1.8
      */
-    export function readdir(
+    function readdir(
         path: PathLike,
         options:
             | {
@@ -2008,7 +2327,7 @@ declare module "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.
      */
-    export function readdir(
+    function readdir(
         path: PathLike,
         options:
             | {
@@ -2024,7 +2343,7 @@ declare module "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.
      */
-    export function readdir(
+    function readdir(
         path: PathLike,
         options:
             | (ObjectEncodingOptions & {
@@ -2040,7 +2359,7 @@ declare module "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.
      */
-    export function readdir(
+    function readdir(
         path: PathLike,
         callback: (err: NodeJS.ErrnoException | null, files: string[]) => void,
     ): void;
@@ -2049,7 +2368,7 @@ declare module "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.
      */
-    export function readdir(
+    function readdir(
         path: PathLike,
         options: ObjectEncodingOptions & {
             withFileTypes: true;
@@ -2062,7 +2381,7 @@ declare module "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'`.
      */
-    export function readdir(
+    function readdir(
         path: PathLike,
         options: {
             encoding: "buffer";
@@ -2071,7 +2390,7 @@ declare module "fs" {
         },
         callback: (err: NodeJS.ErrnoException | null, files: Dirent<NonSharedBuffer>[]) => void,
     ): void;
-    export namespace readdir {
+    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.
@@ -2157,7 +2476,7 @@ declare module "fs" {
      * If `options.withFileTypes` is set to `true`, the result will contain `fs.Dirent` objects.
      * @since v0.1.21
      */
-    export function readdirSync(
+    function readdirSync(
         path: PathLike,
         options?:
             | {
@@ -2173,7 +2492,7 @@ declare module "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.
      */
-    export function readdirSync(
+    function readdirSync(
         path: PathLike,
         options:
             | {
@@ -2188,7 +2507,7 @@ declare module "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.
      */
-    export function readdirSync(
+    function readdirSync(
         path: PathLike,
         options?:
             | (ObjectEncodingOptions & {
@@ -2203,7 +2522,7 @@ declare module "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.
      */
-    export function readdirSync(
+    function readdirSync(
         path: PathLike,
         options: ObjectEncodingOptions & {
             withFileTypes: true;
@@ -2215,7 +2534,7 @@ declare module "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'`.
      */
-    export function readdirSync(
+    function readdirSync(
         path: PathLike,
         options: {
             encoding: "buffer";
@@ -2233,8 +2552,8 @@ declare module "fs" {
      * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
      * @since v0.0.2
      */
-    export function close(fd: number, callback?: NoParamCallback): void;
-    export namespace close {
+    function close(fd: number, callback?: NoParamCallback): void;
+    namespace close {
         /**
          * Asynchronous close(2) - close a file descriptor.
          * @param fd A file descriptor.
@@ -2250,7 +2569,7 @@ declare module "fs" {
      * See the POSIX [`close(2)`](http://man7.org/linux/man-pages/man2/close.2.html) documentation for more detail.
      * @since v0.1.21
      */
-    export function closeSync(fd: number): void;
+    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.
      *
@@ -2268,7 +2587,7 @@ declare module "fs" {
      * @param [flags='r'] See `support of file system `flags``.
      * @param [mode=0o666]
      */
-    export function open(
+    function open(
         path: PathLike,
         flags: OpenMode | undefined,
         mode: Mode | undefined | null,
@@ -2279,7 +2598,7 @@ declare module "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``.
      */
-    export function open(
+    function open(
         path: PathLike,
         flags: OpenMode | undefined,
         callback: (err: NodeJS.ErrnoException | null, fd: number) => void,
@@ -2288,8 +2607,8 @@ declare module "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.
      */
-    export function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
-    export namespace open {
+    function open(path: PathLike, callback: (err: NodeJS.ErrnoException | null, fd: number) => void): void;
+    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.
@@ -2306,7 +2625,7 @@ declare module "fs" {
      * @param [flags='r']
      * @param [mode=0o666]
      */
-    export function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
+    function openSync(path: PathLike, flags: OpenMode, mode?: Mode | null): number;
     /**
      * Change the file system timestamps of the object referenced by `path`.
      *
@@ -2316,8 +2635,8 @@ declare module "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
      */
-    export function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
-    export namespace utimes {
+    function utimes(path: PathLike, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    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.
@@ -2333,14 +2652,14 @@ declare module "fs" {
      * this API: {@link utimes}.
      * @since v0.4.2
      */
-    export function utimesSync(path: PathLike, atime: TimeLike, mtime: TimeLike): void;
+    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
      */
-    export function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
-    export namespace futimes {
+    function futimes(fd: number, atime: TimeLike, mtime: TimeLike, callback: NoParamCallback): void;
+    namespace futimes {
         /**
          * Asynchronously change file timestamps of the file referenced by the supplied file descriptor.
          * @param fd A file descriptor.
@@ -2353,7 +2672,7 @@ declare module "fs" {
      * Synchronous version of {@link futimes}. Returns `undefined`.
      * @since v0.4.2
      */
-    export function futimesSync(fd: number, atime: TimeLike, mtime: TimeLike): void;
+    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.
@@ -2361,8 +2680,8 @@ declare module "fs" {
      * than a possible exception are given to the completion callback.
      * @since v0.1.96
      */
-    export function fsync(fd: number, callback: NoParamCallback): void;
-    export namespace fsync {
+    function fsync(fd: number, callback: NoParamCallback): void;
+    namespace fsync {
         /**
          * Asynchronous fsync(2) - synchronize a file's in-core state with the underlying storage device.
          * @param fd A file descriptor.
@@ -2375,8 +2694,8 @@ declare module "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
      */
-    export function fsyncSync(fd: number): void;
-    export interface WriteOptions {
+    function fsyncSync(fd: number): void;
+    interface WriteOptions {
         /**
          * @default 0
          */
@@ -2417,7 +2736,7 @@ declare module "fs" {
      * @param [length=buffer.byteLength - offset]
      * @param [position='null']
      */
-    export function write<TBuffer extends NodeJS.ArrayBufferView>(
+    function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number | undefined | null,
@@ -2431,7 +2750,7 @@ declare module "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`.
      */
-    export function write<TBuffer extends NodeJS.ArrayBufferView>(
+    function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number | undefined | null,
@@ -2443,7 +2762,7 @@ declare module "fs" {
      * @param fd A file descriptor.
      * @param offset The part of the buffer to be written. If not supplied, defaults to `0`.
      */
-    export function write<TBuffer extends NodeJS.ArrayBufferView>(
+    function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number | undefined | null,
@@ -2453,7 +2772,7 @@ declare module "fs" {
      * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
      * @param fd A file descriptor.
      */
-    export function write<TBuffer extends NodeJS.ArrayBufferView>(
+    function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         callback: (err: NodeJS.ErrnoException | null, written: number, buffer: TBuffer) => void,
@@ -2466,7 +2785,7 @@ declare module "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.
      */
-    export function write<TBuffer extends NodeJS.ArrayBufferView>(
+    function write<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         options: WriteOptions,
@@ -2479,7 +2798,7 @@ declare module "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.
      */
-    export function write(
+    function write(
         fd: number,
         string: string,
         position: number | undefined | null,
@@ -2492,7 +2811,7 @@ declare module "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.
      */
-    export function write(
+    function write(
         fd: number,
         string: string,
         position: number | undefined | null,
@@ -2503,12 +2822,12 @@ declare module "fs" {
      * @param fd A file descriptor.
      * @param string A string to write.
      */
-    export function write(
+    function write(
         fd: number,
         string: string,
         callback: (err: NodeJS.ErrnoException | null, written: number, str: string) => void,
     ): void;
-    export namespace write {
+    namespace write {
         /**
          * Asynchronously writes `buffer` to the file referenced by the supplied file descriptor.
          * @param fd A file descriptor.
@@ -2568,7 +2887,7 @@ declare module "fs" {
      * @param [position='null']
      * @return The number of bytes written.
      */
-    export function writeSync(
+    function writeSync(
         fd: number,
         buffer: NodeJS.ArrayBufferView,
         offset?: number | null,
@@ -2582,14 +2901,14 @@ declare module "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.
      */
-    export function writeSync(
+    function writeSync(
         fd: number,
         string: string,
         position?: number | null,
         encoding?: BufferEncoding | null,
     ): number;
-    export type ReadPosition = number | bigint;
-    export interface ReadOptions {
+    type ReadPosition = number | bigint;
+    interface ReadOptions {
         /**
          * @default 0
          */
@@ -2603,15 +2922,9 @@ declare module "fs" {
          */
         position?: ReadPosition | null | undefined;
     }
-    export interface ReadOptionsWithBuffer<T extends NodeJS.ArrayBufferView> extends ReadOptions {
+    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`.
      *
@@ -2629,7 +2942,7 @@ declare module "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.
      */
-    export function read<TBuffer extends NodeJS.ArrayBufferView>(
+    function read<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         offset: number,
@@ -2646,27 +2959,27 @@ declare module "fs" {
      * `position` defaults to `null`
      * @since v12.17.0, 13.11.0
      */
-    export function read<TBuffer extends NodeJS.ArrayBufferView = NonSharedBuffer>(
+    function read<TBuffer extends NodeJS.ArrayBufferView = NonSharedBuffer>(
         fd: number,
         options: ReadOptionsWithBuffer<TBuffer>,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void,
     ): void;
-    export function read<TBuffer extends NodeJS.ArrayBufferView>(
+    function read<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         options: ReadOptions,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void,
     ): void;
-    export function read<TBuffer extends NodeJS.ArrayBufferView>(
+    function read<TBuffer extends NodeJS.ArrayBufferView>(
         fd: number,
         buffer: TBuffer,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: TBuffer) => void,
     ): void;
-    export function read(
+    function read(
         fd: number,
         callback: (err: NodeJS.ErrnoException | null, bytesRead: number, buffer: NonSharedBuffer) => void,
     ): void;
-    export namespace read {
+    namespace read {
         /**
          * @param fd A file descriptor.
          * @param buffer The buffer that the data will be written to.
@@ -2704,7 +3017,7 @@ declare module "fs" {
      * @since v0.1.21
      * @param [position='null']
      */
-    export function readSync(
+    function readSync(
         fd: number,
         buffer: NodeJS.ArrayBufferView,
         offset: number,
@@ -2715,7 +3028,20 @@ declare module "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.
      */
-    export function readSync(fd: number, buffer: NodeJS.ArrayBufferView, opts?: ReadOptions): number;
+    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);
+    }
     /**
      * Asynchronously reads the entire contents of a file.
      *
@@ -2733,6 +3059,11 @@ declare module "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
@@ -2741,7 +3072,8 @@ declare module "fs" {
      * readFile('/etc/passwd', 'utf8', callback);
      * ```
      *
-     * When the path is a directory, the behavior of `fs.readFile()` and {@link readFileSync} is platform-specific. On macOS, Linux, and Windows, an
+     * When the path is a directory, the behavior of `fs.readFile()` and
+     * `fs.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.
      *
@@ -2779,65 +3111,61 @@ declare module "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
      */
-    export function readFile(
+    function readFile<T extends NodeJS.ArrayBufferView>(
         path: PathOrFileDescriptor,
-        options:
-            | ({
-                encoding?: null | undefined;
-                flag?: string | undefined;
-            } & Abortable)
-            | undefined
-            | null,
+        options: ReadFileOptionsWithBuffer<T>,
+        callback: (err: NodeJS.ErrnoException | null, data: BufferView<T>) => void,
+    ): void;
+    function readFile(
+        path: PathOrFileDescriptor,
+        options: ReadFileOptionsWithBufferEncoding | null | undefined,
         callback: (err: NodeJS.ErrnoException | null, data: NonSharedBuffer) => void,
     ): void;
-    /**
-     * 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(
+    function readFile(
         path: PathOrFileDescriptor,
-        options:
-            | ({
-                encoding: BufferEncoding;
-                flag?: string | undefined;
-            } & Abortable)
-            | BufferEncoding,
+        options: ReadFileOptionsWithStringEncoding | BufferEncoding,
         callback: (err: NodeJS.ErrnoException | null, data: string) => void,
     ): void;
-    /**
-     * 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(
+    function readFile(
         path: PathOrFileDescriptor,
-        options:
-            | (ObjectEncodingOptions & {
-                flag?: string | undefined;
-            } & Abortable)
-            | BufferEncoding
-            | undefined
-            | null,
+        options: ReadFileOptions | BufferEncoding | null | undefined,
         callback: (err: NodeJS.ErrnoException | null, data: string | NonSharedBuffer) => void,
     ): void;
-    /**
-     * 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(
+    function readFile(
         path: PathOrFileDescriptor,
         callback: (err: NodeJS.ErrnoException | null, data: NonSharedBuffer) => void,
     ): void;
-    export namespace readFile {
+    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.
@@ -2887,16 +3215,37 @@ declare module "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: {@link readFile}.
+     * this API: `fs.readFile()`.
      *
      * If the `encoding` option is specified then this function returns a
      * string. Otherwise it returns a buffer.
      *
-     * Similar to {@link readFile}, when the path is a directory, the behavior of `fs.readFileSync()` is platform-specific.
+     * 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.
      *
      * ```js
      * import { readFileSync } from 'node:fs';
@@ -2911,46 +3260,20 @@ declare module "fs" {
      * @since v0.1.8
      * @param path filename or file descriptor
      */
-    export function readFileSync(
+    function readFileSync<T extends NodeJS.ArrayBufferView>(
+        path: PathOrFileDescriptor,
+        options: ReadFileSyncOptionsWithBuffer<T>,
+    ): BufferView<T>;
+    function readFileSync(
         path: PathOrFileDescriptor,
-        options?: {
-            encoding?: null | undefined;
-            flag?: string | undefined;
-        } | null,
+        options?: ReadFileSyncOptionsWithBufferEncoding | null,
     ): NonSharedBuffer;
-    /**
-     * 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(
+    function readFileSync(
         path: PathOrFileDescriptor,
-        options:
-            | {
-                encoding: BufferEncoding;
-                flag?: string | undefined;
-            }
-            | BufferEncoding,
+        options: ReadFileSyncOptionsWithStringEncoding | BufferEncoding,
     ): string;
-    /**
-     * 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 =
+    function readFileSync(path: PathOrFileDescriptor, options: ReadFileSyncOptions): string | NonSharedBuffer;
+    type WriteFileOptions =
         | (
             & ObjectEncodingOptions
             & Abortable
@@ -3023,7 +3346,7 @@ declare module "fs" {
      * @since v0.1.29
      * @param file filename or file descriptor
      */
-    export function writeFile(
+    function writeFile(
         file: PathOrFileDescriptor,
         data: string | NodeJS.ArrayBufferView,
         options: WriteFileOptions,
@@ -3035,12 +3358,12 @@ declare module "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.
      */
-    export function writeFile(
+    function writeFile(
         path: PathOrFileDescriptor,
         data: string | NodeJS.ArrayBufferView,
         callback: NoParamCallback,
     ): void;
-    export namespace writeFile {
+    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.
@@ -3069,7 +3392,7 @@ declare module "fs" {
      * @since v0.1.29
      * @param file filename or file descriptor
      */
-    export function writeFileSync(
+    function writeFileSync(
         file: PathOrFileDescriptor,
         data: string | NodeJS.ArrayBufferView,
         options?: WriteFileOptions,
@@ -3127,7 +3450,7 @@ declare module "fs" {
      * @since v0.6.7
      * @param path filename or file descriptor
      */
-    export function appendFile(
+    function appendFile(
         path: PathOrFileDescriptor,
         data: string | Uint8Array,
         options: WriteFileOptions,
@@ -3139,8 +3462,8 @@ declare module "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.
      */
-    export function appendFile(file: PathOrFileDescriptor, data: string | Uint8Array, callback: NoParamCallback): void;
-    export namespace appendFile {
+    function appendFile(file: PathOrFileDescriptor, data: string | Uint8Array, callback: NoParamCallback): void;
+    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.
@@ -3206,7 +3529,7 @@ declare module "fs" {
      * @since v0.6.7
      * @param path filename or file descriptor
      */
-    export function appendFileSync(
+    function appendFileSync(
         path: PathOrFileDescriptor,
         data: string | Uint8Array,
         options?: WriteFileOptions,
@@ -3257,7 +3580,7 @@ declare module "fs" {
      * * the file is renamed and then renamed a second time back to its original name
      * @since v0.1.31
      */
-    export interface WatchFileOptions {
+    interface WatchFileOptions {
         bigint?: boolean | undefined;
         persistent?: boolean | undefined;
         interval?: number | undefined;
@@ -3308,7 +3631,7 @@ declare module "fs" {
      * * the file is renamed and then renamed a second time back to its original name
      * @since v0.1.31
      */
-    export function watchFile(
+    function watchFile(
         filename: PathLike,
         options:
             | (WatchFileOptions & {
@@ -3317,7 +3640,7 @@ declare module "fs" {
             | undefined,
         listener: StatsListener,
     ): StatWatcher;
-    export function watchFile(
+    function watchFile(
         filename: PathLike,
         options:
             | (WatchFileOptions & {
@@ -3330,7 +3653,7 @@ declare module "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.
      */
-    export function watchFile(filename: PathLike, listener: StatsListener): StatWatcher;
+    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,
@@ -3343,23 +3666,25 @@ declare module "fs" {
      * @since v0.1.31
      * @param listener Optional, a listener previously attached using `fs.watchFile()`
      */
-    export function unwatchFile(filename: PathLike, listener?: StatsListener): void;
-    export function unwatchFile(filename: PathLike, listener?: BigIntStatsListener): void;
-    export interface WatchOptions extends Abortable {
+    function unwatchFile(filename: PathLike, listener?: StatsListener): void;
+    function unwatchFile(filename: PathLike, listener?: BigIntStatsListener): void;
+    type WatchIgnorePredicate = string | RegExp | ((filename: string) => boolean);
+    interface WatchOptions extends Abortable {
         encoding?: BufferEncoding | "buffer" | undefined;
         persistent?: boolean | undefined;
         recursive?: boolean | undefined;
+        ignore?: WatchIgnorePredicate | readonly WatchIgnorePredicate[] | undefined;
     }
-    export interface WatchOptionsWithBufferEncoding extends WatchOptions {
+    interface WatchOptionsWithBufferEncoding extends WatchOptions {
         encoding: "buffer";
     }
-    export interface WatchOptionsWithStringEncoding extends WatchOptions {
+    interface WatchOptionsWithStringEncoding extends WatchOptions {
         encoding?: BufferEncoding | undefined;
     }
-    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;
+    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;
     /**
      * Watch for changes on `filename`, where `filename` is either a file or a
      * directory.
@@ -3380,22 +3705,22 @@ declare module "fs" {
      * @since v0.5.10
      * @param listener
      */
-    export function watch(
+    function watch(
         filename: PathLike,
         options?: WatchOptionsWithStringEncoding | BufferEncoding | null,
         listener?: WatchListener<string>,
     ): FSWatcher;
-    export function watch(
+    function watch(
         filename: PathLike,
         options: WatchOptionsWithBufferEncoding | "buffer",
         listener: WatchListener<NonSharedBuffer>,
     ): FSWatcher;
-    export function watch(
+    function watch(
         filename: PathLike,
         options: WatchOptions | BufferEncoding | "buffer" | null,
         listener: WatchListener<string | NonSharedBuffer>,
     ): FSWatcher;
-    export function watch(filename: PathLike, listener: WatchListener<string>): FSWatcher;
+    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:
@@ -3525,9 +3850,9 @@ declare module "fs" {
      * @since v0.0.2
      * @deprecated Since v1.0.0 - Use {@link stat} or {@link access} instead.
      */
-    export function exists(path: PathLike, callback: (exists: boolean) => void): void;
+    function exists(path: PathLike, callback: (exists: boolean) => void): void;
     /** @deprecated */
-    export namespace exists {
+    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_.
@@ -3551,8 +3876,8 @@ declare module "fs" {
      * ```
      * @since v0.1.21
      */
-    export function existsSync(path: PathLike): boolean;
-    export namespace constants {
+    function existsSync(path: PathLike): boolean;
+    namespace constants {
         // File Access Constants
         /** Constant for fs.access(). File is visible to the calling process. */
         const F_OK: number;
@@ -3826,13 +4151,13 @@ declare module "fs" {
      * @since v0.11.15
      * @param [mode=fs.constants.F_OK]
      */
-    export function access(path: PathLike, mode: number | undefined, callback: NoParamCallback): void;
+    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.
      */
-    export function access(path: PathLike, callback: NoParamCallback): void;
-    export namespace access {
+    function access(path: PathLike, callback: NoParamCallback): void;
+    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.
@@ -3863,11 +4188,11 @@ declare module "fs" {
      * @since v0.11.15
      * @param [mode=fs.constants.F_OK]
      */
-    export function accessSync(path: PathLike, mode?: number): void;
+    function accessSync(path: PathLike, mode?: number): void;
     interface StreamOptions {
         flags?: string | undefined;
         encoding?: BufferEncoding | undefined;
-        fd?: number | promises.FileHandle | undefined;
+        fd?: number | FileHandle | undefined;
         mode?: number | undefined;
         autoClose?: boolean | undefined;
         emitClose?: boolean | undefined;
@@ -3955,7 +4280,7 @@ declare module "fs" {
      * If `options` is a string, then it specifies the encoding.
      * @since v0.1.31
      */
-    export function createReadStream(path: PathLike, options?: BufferEncoding | ReadStreamOptions): ReadStream;
+    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
@@ -3983,7 +4308,7 @@ declare module "fs" {
      * If `options` is a string, then it specifies the encoding.
      * @since v0.1.31
      */
-    export function createWriteStream(path: PathLike, options?: BufferEncoding | WriteStreamOptions): WriteStream;
+    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
@@ -3991,8 +4316,8 @@ declare module "fs" {
      * exception are given to the completion callback.
      * @since v0.1.96
      */
-    export function fdatasync(fd: number, callback: NoParamCallback): void;
-    export namespace fdatasync {
+    function fdatasync(fd: number, callback: NoParamCallback): void;
+    namespace fdatasync {
         /**
          * Asynchronous fdatasync(2) - synchronize a file's in-core state with storage device.
          * @param fd A file descriptor.
@@ -4004,7 +4329,7 @@ declare module "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
      */
-    export function fdatasyncSync(fd: number): void;
+    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
@@ -4044,9 +4369,9 @@ declare module "fs" {
      * @param dest destination filename of the copy operation
      * @param [mode=0] modifiers for copy operation.
      */
-    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 copyFile(src: PathLike, dest: PathLike, callback: NoParamCallback): void;
+    function copyFile(src: PathLike, dest: PathLike, mode: number, callback: NoParamCallback): void;
+    namespace copyFile {
         function __promisify__(src: PathLike, dst: PathLike, mode?: number): Promise<void>;
     }
     /**
@@ -4083,7 +4408,7 @@ declare module "fs" {
      * @param dest destination filename of the copy operation
      * @param [mode=0] modifiers for copy operation.
      */
-    export function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
+    function copyFileSync(src: PathLike, dest: PathLike, mode?: number): void;
     /**
      * Write an array of `ArrayBufferView`s to the file specified by `fd` using `writev()`.
      *
@@ -4104,12 +4429,12 @@ declare module "fs" {
      * @since v12.9.0
      * @param [position='null']
      */
-    export function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
+    function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
         fd: number,
         buffers: TBuffers,
         cb: (err: NodeJS.ErrnoException | null, bytesWritten: number, buffers: TBuffers) => void,
     ): void;
-    export function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
+    function writev<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
         fd: number,
         buffers: TBuffers,
         position: number | null,
@@ -4117,11 +4442,11 @@ declare module "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
-    export interface WriteVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
+    interface WriteVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
         bytesWritten: number;
         buffers: T;
     }
-    export namespace writev {
+    namespace writev {
         function __promisify__<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
             fd: number,
             buffers: TBuffers,
@@ -4135,7 +4460,7 @@ declare module "fs" {
      * @param [position='null']
      * @return The number of bytes written.
      */
-    export function writevSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
+    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()`.
@@ -4151,12 +4476,12 @@ declare module "fs" {
      * @since v13.13.0, v12.17.0
      * @param [position='null']
      */
-    export function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
+    function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
         fd: number,
         buffers: TBuffers,
         cb: (err: NodeJS.ErrnoException | null, bytesRead: number, buffers: TBuffers) => void,
     ): void;
-    export function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
+    function readv<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
         fd: number,
         buffers: TBuffers,
         position: number | null,
@@ -4164,11 +4489,11 @@ declare module "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
-    export interface ReadVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
+    interface ReadVResult<T extends readonly NodeJS.ArrayBufferView[] = NodeJS.ArrayBufferView[]> {
         bytesRead: number;
         buffers: T;
     }
-    export namespace readv {
+    namespace readv {
         function __promisify__<TBuffers extends readonly NodeJS.ArrayBufferView[]>(
             fd: number,
             buffers: TBuffers,
@@ -4182,9 +4507,9 @@ declare module "fs" {
      * @param [position='null']
      * @return The number of bytes read.
      */
-    export function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
+    function readvSync(fd: number, buffers: readonly NodeJS.ArrayBufferView[], position?: number): number;
 
-    export interface OpenAsBlobOptions {
+    interface OpenAsBlobOptions {
         /**
          * An optional mime type for the blob.
          *
@@ -4210,9 +4535,9 @@ declare module "fs" {
      * ```
      * @since v19.8.0
      */
-    export function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
+    function openAsBlob(path: PathLike, options?: OpenAsBlobOptions): Promise<Blob>;
 
-    export interface OpenDirOptions {
+    interface OpenDirOptions {
         /**
          * @default 'utf8'
          */
@@ -4239,7 +4564,7 @@ declare module "fs" {
      * directory and subsequent read operations.
      * @since v12.12.0
      */
-    export function opendirSync(path: PathLike, options?: OpenDirOptions): Dir;
+    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.
@@ -4251,30 +4576,31 @@ declare module "fs" {
      * directory and subsequent read operations.
      * @since v12.12.0
      */
-    export function opendir(path: PathLike, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
-    export function opendir(
+    function opendir(path: PathLike, cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void): void;
+    function opendir(
         path: PathLike,
         options: OpenDirOptions,
         cb: (err: NodeJS.ErrnoException | null, dir: Dir) => void,
     ): void;
-    export namespace opendir {
+    namespace opendir {
         function __promisify__(path: PathLike, options?: OpenDirOptions): Promise<Dir>;
     }
-    export interface BigIntStats extends StatsBase<bigint> {
+    interface BigIntStats extends StatsBase<bigint> {
         atimeNs: bigint;
         mtimeNs: bigint;
         ctimeNs: bigint;
         birthtimeNs: bigint;
     }
-    export interface BigIntOptions {
+    interface BigIntOptions {
         bigint: true;
     }
-    export interface StatOptions {
+    interface StatOptions {
+        // TODO: add signal option once we sort its behavior out upstream
         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
@@ -4315,14 +4641,14 @@ declare module "fs" {
          */
         verbatimSymlinks?: boolean | undefined;
     }
-    export interface CopyOptions extends CopyOptionsBase {
+    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;
     }
-    export interface CopySyncOptions extends CopyOptionsBase {
+    interface CopySyncOptions extends CopyOptionsBase {
         /**
          * Function to filter copied files/directories. Return
          * `true` to copy the item, `false` to ignore it.
@@ -4340,12 +4666,12 @@ declare module "fs" {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    export function cp(
+    function cp(
         source: string | URL,
         destination: string | URL,
         callback: (err: NodeJS.ErrnoException | null) => void,
     ): void;
-    export function cp(
+    function cp(
         source: string | URL,
         destination: string | URL,
         opts: CopyOptions,
@@ -4362,41 +4688,49 @@ declare module "fs" {
      * @param src source path to copy.
      * @param dest destination path to copy to.
      */
-    export function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
-
-    interface _GlobOptions<T extends Dirent | string> {
+    function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
+    interface GlobOptions<T extends Dirent | string = Dirent | string> {
         /**
          * Current working directory.
          * @default process.cwd()
          */
         cwd?: string | URL | 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.
+         * `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;
     }
-    export interface GlobOptions extends _GlobOptions<Dirent | string> {}
-    export interface GlobOptionsWithFileTypes extends _GlobOptions<Dirent> {
+    interface GlobOptionsWithFileTypes extends GlobOptions<Dirent> {
         withFileTypes: true;
     }
-    export interface GlobOptionsWithoutFileTypes extends _GlobOptions<string> {
+    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';
      *
@@ -4407,11 +4741,11 @@ declare module "fs" {
      * ```
      * @since v22.0.0
      */
-    export function glob(
+    function glob(
         pattern: string | readonly string[],
         callback: (err: NodeJS.ErrnoException | null, matches: string[]) => void,
     ): void;
-    export function glob(
+    function glob(
         pattern: string | readonly string[],
         options: GlobOptionsWithFileTypes,
         callback: (
@@ -4419,7 +4753,7 @@ declare module "fs" {
             matches: Dirent[],
         ) => void,
     ): void;
-    export function glob(
+    function glob(
         pattern: string | readonly string[],
         options: GlobOptionsWithoutFileTypes,
         callback: (
@@ -4427,7 +4761,7 @@ declare module "fs" {
             matches: string[],
         ) => void,
     ): void;
-    export function glob(
+    function glob(
         pattern: string | readonly string[],
         options: GlobOptions,
         callback: (
@@ -4436,6 +4770,9 @@ declare module "fs" {
         ) => void,
     ): void;
     /**
+     * When `followSymlinks` is enabled, detected symbolic link cycles are not
+     * traversed recursively.
+     *
      * ```js
      * import { globSync } from 'node:fs';
      *
@@ -4444,20 +4781,23 @@ declare module "fs" {
      * @since v22.0.0
      * @returns paths of files that match the pattern.
      */
-    export function globSync(pattern: string | readonly string[]): string[];
-    export function globSync(
+    function globSync(pattern: string | readonly string[]): string[];
+    function globSync(
         pattern: string | readonly string[],
         options: GlobOptionsWithFileTypes,
     ): Dirent[];
-    export function globSync(
+    function globSync(
         pattern: string | readonly string[],
         options: GlobOptionsWithoutFileTypes,
     ): string[];
-    export function globSync(
+    function globSync(
         pattern: string | readonly string[],
         options: GlobOptions,
     ): Dirent[] | string[];
 }
 declare module "node:fs" {
-    export * from "fs";
+    export * as promises from "node:fs/promises";
+}
+declare module "fs" {
+    export * from "node:fs";
 }