node-red-contrib-tak-registration 0.11.4 → 0.11.6

package/node_modules/@types/node/README.md

@@ -8,7 +8,7 @@ This package contains type definitions for node (https://nodejs.org/).
 Files were exported from https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node.
 
 ### Additional Details
- * Last updated: Thu, 07 Dec 2023 07:07:09 GMT
+ * Last updated: Thu, 22 Feb 2024 18:35:22 GMT
  * Dependencies: [undici-types](https://npmjs.com/package/undici-types)
 
 # Credits

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

@@ -128,9 +128,10 @@ declare module "buffer" {
      */
     export interface BlobOptions {
         /**
-         * @default 'utf8'
+         * One of either `'transparent'` or `'native'`. When set to `'native'`, line endings in string source parts
+         * will be converted to the platform native line-ending as specified by `require('node:os').EOL`.
          */
-        encoding?: BufferEncoding | undefined;
+        endings?: "transparent" | "native";
         /**
          * The Blob content-type. The intent is for `type` to convey
          * the MIME media type of the data, however no validation of the type format
@@ -162,7 +163,7 @@ declare module "buffer" {
          *
          * String sources are also copied into the `Blob`.
          */
-        constructor(sources: Array<BinaryLike | Blob>, options?: BlobOptions);
+        constructor(sources: Array<ArrayBuffer | BinaryLike | Blob>, options?: BlobOptions);
         /**
          * Returns a promise that fulfills with an [ArrayBuffer](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer) containing a copy of
          * the `Blob` data.
@@ -415,7 +416,7 @@ declare module "buffer" {
              * @return The number of bytes contained within `string`.
              */
             byteLength(
-                string: string | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
+                string: string | Buffer | NodeJS.ArrayBufferView | ArrayBuffer | SharedArrayBuffer,
                 encoding?: BufferEncoding,
             ): number;
             /**
@@ -470,7 +471,7 @@ declare module "buffer" {
              * ```
              * @since v19.8.0
              * @param view The {TypedArray} to copy.
-             * @param [offset=': 0'] The starting offset within `view`.
+             * @param [offset=0] The starting offset within `view`.
              * @param [length=view.length - offset] The number of elements from `view` to copy.
              */
             copyBytesFrom(view: NodeJS.TypedArray, offset?: number, length?: number): Buffer;
@@ -563,8 +564,8 @@ declare module "buffer" {
              * A `TypeError` will be thrown if `size` is not a number.
              *
              * The `Buffer` module pre-allocates an internal `Buffer` instance of
-             * size `Buffer.poolSize` that is used as a pool for the fast allocation of new`Buffer` instances created using `Buffer.allocUnsafe()`, `Buffer.from(array)`,
-             * and `Buffer.concat()` only when `size` is less than or equal to`Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two).
+             * size `Buffer.poolSize` that is used as a pool for the fast allocation of new `Buffer` instances created using `Buffer.allocUnsafe()`, `Buffer.from(array)`,
+             * and `Buffer.concat()` only when `size` is less than `Buffer.poolSize >>> 1` (floor of `Buffer.poolSize` divided by two).
              *
              * Use of this pre-allocated internal memory pool is a key difference between
              * calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.

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

@@ -100,6 +100,8 @@ declare module "crypto" {
         const OPENSSL_VERSION_NUMBER: number;
         /** Applies multiple bug workarounds within OpenSSL. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html for detail. */
         const SSL_OP_ALL: number;
+        /** Instructs OpenSSL to allow a non-[EC]DHE-based key exchange mode for TLS v1.3 */
+        const SSL_OP_ALLOW_NO_DHE_KEX: number;
         /** Allows legacy insecure renegotiation between OpenSSL and unpatched clients or servers. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
         const SSL_OP_ALLOW_UNSAFE_LEGACY_RENEGOTIATION: number;
         /** Attempts to use the server's preferences instead of the client's when selecting a cipher. See https://www.openssl.org/docs/man1.0.2/ssl/SSL_CTX_set_options.html. */
@@ -116,15 +118,29 @@ declare module "crypto" {
         const SSL_OP_LEGACY_SERVER_CONNECT: number;
         /** Instructs OpenSSL to disable support for SSL/TLS compression. */
         const SSL_OP_NO_COMPRESSION: number;
+        /** Instructs OpenSSL to disable encrypt-then-MAC. */
+        const SSL_OP_NO_ENCRYPT_THEN_MAC: number;
         const SSL_OP_NO_QUERY_MTU: number;
+        /** Instructs OpenSSL to disable renegotiation. */
+        const SSL_OP_NO_RENEGOTIATION: number;
         /** Instructs OpenSSL to always start a new session when performing renegotiation. */
         const SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION: number;
+        /** Instructs OpenSSL to turn off SSL v2 */
         const SSL_OP_NO_SSLv2: number;
+        /** Instructs OpenSSL to turn off SSL v3 */
         const SSL_OP_NO_SSLv3: number;
+        /** Instructs OpenSSL to disable use of RFC4507bis tickets. */
         const SSL_OP_NO_TICKET: number;
+        /** Instructs OpenSSL to turn off TLS v1 */
         const SSL_OP_NO_TLSv1: number;
+        /** Instructs OpenSSL to turn off TLS v1.1 */
         const SSL_OP_NO_TLSv1_1: number;
+        /** Instructs OpenSSL to turn off TLS v1.2 */
         const SSL_OP_NO_TLSv1_2: number;
+        /** Instructs OpenSSL to turn off TLS v1.3 */
+        const SSL_OP_NO_TLSv1_3: number;
+        /** Instructs OpenSSL server to prioritize ChaCha20-Poly1305 when the client does. This option has no effect if `SSL_OP_CIPHER_SERVER_PREFERENCE` is not enabled. */
+        const SSL_OP_PRIORITIZE_CHACHA: number;
         /** Instructs OpenSSL to disable version rollback attack detection. */
         const SSL_OP_TLS_ROLLBACK_BUG: number;
         const ENGINE_METHOD_RSA: number;
@@ -363,7 +379,7 @@ declare module "crypto" {
          * @since v13.1.0
          * @param options `stream.transform` options
          */
-        copy(options?: stream.TransformOptions): Hash;
+        copy(options?: HashOptions): Hash;
         /**
          * Updates the hash content with the given `data`, the encoding of which
          * is given in `inputEncoding`.
@@ -637,6 +653,13 @@ declare module "crypto" {
         export(options: KeyExportOptions<"pem">): string | Buffer;
         export(options?: KeyExportOptions<"der">): Buffer;
         export(options?: JwkKeyExportOptions): JsonWebKey;
+        /**
+         * Returns `true` or `false` depending on whether the keys have exactly the same
+         * type, value, and parameters. This method is not [constant time](https://en.wikipedia.org/wiki/Timing_attack).
+         * @since v17.7.0, v16.15.0
+         * @param otherKeyObject A `KeyObject` with which to compare `keyObject`.
+         */
+        equals(otherKeyObject: KeyObject): boolean;
         /**
          * For secret keys, this property represents the size of the key in bytes. This
          * property is `undefined` for asymmetric keys.
@@ -1897,7 +1920,7 @@ declare module "crypto" {
      * Return a random integer `n` such that `min <= n < max`.  This
      * implementation avoids [modulo bias](https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle#Modulo_bias).
      *
-     * The range (`max - min`) must be less than 248. `min` and `max` must
+     * The range (`max - min`) must be less than 2**48. `min` and `max` must
      * be [safe integers](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger).
      *
      * If the `callback` function is not provided, the random integer is
@@ -2475,6 +2498,10 @@ declare module "crypto" {
          * Name of the curve to use
          */
         namedCurve: string;
+        /**
+         * Must be `'named'` or `'explicit'`. Default: `'named'`.
+         */
+        paramEncoding?: "explicit" | "named" | undefined;
     }
     interface RSAKeyPairKeyObjectOptions {
         /**
@@ -2585,11 +2612,7 @@ declare module "crypto" {
             type: "pkcs8";
         };
     }
-    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> {
-        /**
-         * Name of the curve to use.
-         */
-        namedCurve: string;
+    interface ECKeyPairOptions<PubF extends KeyFormat, PrivF extends KeyFormat> extends ECKeyPairKeyObjectOptions {
         publicKeyEncoding: {
             type: "pkcs1" | "spki";
             format: PubF;
@@ -4450,6 +4473,14 @@ declare module "crypto" {
             ): Promise<ArrayBuffer>;
         }
     }
+
+    global {
+        var crypto: typeof globalThis extends {
+            crypto: infer T;
+            onmessage: any;
+        } ? T
+            : webcrypto.Crypto;
+    }
 }
 declare module "node:crypto" {
     export * from "crypto";

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

@@ -227,6 +227,16 @@ declare module "dgram" {
          * @return the `SO_SNDBUF` socket send buffer size in bytes.
          */
         getSendBufferSize(): number;
+        /**
+         * @since v18.8.0, v16.19.0
+         * @return Number of bytes queued for sending.
+         */
+        getSendQueueSize(): number;
+        /**
+         * @since v18.8.0, v16.19.0
+         * @return Number of send requests currently in the queue awaiting to be processed.
+         */
+        getSendQueueCount(): number;
         /**
          * By default, binding a socket will cause it to block the Node.js process from
          * exiting as long as the socket is open. The `socket.unref()` method can be used

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

@@ -23,6 +23,7 @@
  * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/diagnostics_channel.js)
  */
 declare module "diagnostics_channel" {
+    import { AsyncLocalStorage } from "node:async_hooks";
     /**
      * Check if there are active subscribers to the named channel. This is helpful if
      * the message you want to send might be expensive to prepare.
@@ -95,6 +96,36 @@ declare module "diagnostics_channel" {
      * @return `true` if the handler was found, `false` otherwise.
      */
     function unsubscribe(name: string | symbol, onMessage: ChannelListener): boolean;
+    /**
+     * Creates a `TracingChannel` wrapper for the given `TracingChannel Channels`. If a name is given, the corresponding tracing
+     * channels will be created in the form of `tracing:${name}:${eventType}` where`eventType` corresponds to the types of `TracingChannel Channels`.
+     *
+     * ```js
+     * import diagnostics_channel from 'node:diagnostics_channel';
+     *
+     * const channelsByName = diagnostics_channel.tracingChannel('my-channel');
+     *
+     * // or...
+     *
+     * const channelsByCollection = diagnostics_channel.tracingChannel({
+     *   start: diagnostics_channel.channel('tracing:my-channel:start'),
+     *   end: diagnostics_channel.channel('tracing:my-channel:end'),
+     *   asyncStart: diagnostics_channel.channel('tracing:my-channel:asyncStart'),
+     *   asyncEnd: diagnostics_channel.channel('tracing:my-channel:asyncEnd'),
+     *   error: diagnostics_channel.channel('tracing:my-channel:error'),
+     * });
+     * ```
+     * @since v19.9.0
+     * @experimental
+     * @param nameOrChannels Channel name or object containing all the `TracingChannel Channels`
+     * @return Collection of channels to trace with
+     */
+    function tracingChannel<
+        StoreType = unknown,
+        ContextType extends object = StoreType extends object ? StoreType : object,
+    >(
+        nameOrChannels: string | TracingChannelCollection<StoreType, ContextType>,
+    ): TracingChannel<StoreType, ContextType>;
     /**
      * The class `Channel` represents an individual named channel within the data
      * pipeline. It is used to track subscribers and to publish messages when there
@@ -104,7 +135,7 @@ declare module "diagnostics_channel" {
      * with `new Channel(name)` is not supported.
      * @since v15.1.0, v14.17.0
      */
-    class Channel {
+    class Channel<StoreType = unknown, ContextType = StoreType> {
         readonly name: string | symbol;
         /**
          * Check if there are active subscribers to this channel. This is helpful if
@@ -184,6 +215,329 @@ declare module "diagnostics_channel" {
          * @return `true` if the handler was found, `false` otherwise.
          */
         unsubscribe(onMessage: ChannelListener): void;
+        /**
+         * When `channel.runStores(context, ...)` is called, the given context data
+         * will be applied to any store bound to the channel. If the store has already been
+         * bound the previous `transform` function will be replaced with the new one.
+         * The `transform` function may be omitted to set the given context data as the
+         * context directly.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store, (data) => {
+         *   return { data };
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param store The store to which to bind the context data
+         * @param transform Transform context data before setting the store context
+         */
+        bindStore(store: AsyncLocalStorage<StoreType>, transform?: (context: ContextType) => StoreType): void;
+        /**
+         * Remove a message handler previously registered to this channel with `channel.bindStore(store)`.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store);
+         * channel.unbindStore(store);
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param store The store to unbind from the channel.
+         * @return `true` if the store was found, `false` otherwise.
+         */
+        unbindStore(store: any): void;
+        /**
+         * Applies the given data to any AsyncLocalStorage instances bound to the channel
+         * for the duration of the given function, then publishes to the channel within
+         * the scope of that data is applied to the stores.
+         *
+         * If a transform function was given to `channel.bindStore(store)` it will be
+         * applied to transform the message data before it becomes the context value for
+         * the store. The prior storage context is accessible from within the transform
+         * function in cases where context linking is required.
+         *
+         * The context applied to the store should be accessible in any async code which
+         * continues from execution which began during the given function, however
+         * there are some situations in which `context loss` may occur.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const store = new AsyncLocalStorage();
+         *
+         * const channel = diagnostics_channel.channel('my-channel');
+         *
+         * channel.bindStore(store, (message) => {
+         *   const parent = store.getStore();
+         *   return new Span(message, parent);
+         * });
+         * channel.runStores({ some: 'message' }, () => {
+         *   store.getStore(); // Span({ some: 'message' })
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param context Message to send to subscribers and bind to stores
+         * @param fn Handler to run within the entered storage context
+         * @param thisArg The receiver to be used for the function call.
+         * @param args Optional arguments to pass to the function.
+         */
+        runStores(): void;
+    }
+    interface TracingChannelSubscribers<ContextType extends object> {
+        start: (message: ContextType) => void;
+        end: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        asyncStart: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        asyncEnd: (
+            message: ContextType & {
+                error?: unknown;
+                result?: unknown;
+            },
+        ) => void;
+        error: (
+            message: ContextType & {
+                error: unknown;
+            },
+        ) => void;
+    }
+    interface TracingChannelCollection<StoreType = unknown, ContextType = StoreType> {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+    }
+    /**
+     * The class `TracingChannel` is a collection of `TracingChannel Channels` which
+     * together express a single traceable action. It is used to formalize and
+     * simplify the process of producing events for tracing application flow.{@link tracingChannel} is used to construct a`TracingChannel`. As with `Channel` it is recommended to create and reuse a
+     * single `TracingChannel` at the top-level of the file rather than creating them
+     * dynamically.
+     * @since v19.9.0
+     * @experimental
+     */
+    class TracingChannel<StoreType = unknown, ContextType extends object = {}> implements TracingChannelCollection {
+        start: Channel<StoreType, ContextType>;
+        end: Channel<StoreType, ContextType>;
+        asyncStart: Channel<StoreType, ContextType>;
+        asyncEnd: Channel<StoreType, ContextType>;
+        error: Channel<StoreType, ContextType>;
+        /**
+         * Helper to subscribe a collection of functions to the corresponding channels.
+         * This is the same as calling `channel.subscribe(onMessage)` on each channel
+         * individually.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.subscribe({
+         *   start(message) {
+         *     // Handle start message
+         *   },
+         *   end(message) {
+         *     // Handle end message
+         *   },
+         *   asyncStart(message) {
+         *     // Handle asyncStart message
+         *   },
+         *   asyncEnd(message) {
+         *     // Handle asyncEnd message
+         *   },
+         *   error(message) {
+         *     // Handle error message
+         *   },
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param subscribers Set of `TracingChannel Channels` subscribers
+         */
+        subscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        /**
+         * Helper to unsubscribe a collection of functions from the corresponding channels.
+         * This is the same as calling `channel.unsubscribe(onMessage)` on each channel
+         * individually.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.unsubscribe({
+         *   start(message) {
+         *     // Handle start message
+         *   },
+         *   end(message) {
+         *     // Handle end message
+         *   },
+         *   asyncStart(message) {
+         *     // Handle asyncStart message
+         *   },
+         *   asyncEnd(message) {
+         *     // Handle asyncEnd message
+         *   },
+         *   error(message) {
+         *     // Handle error message
+         *   },
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param subscribers Set of `TracingChannel Channels` subscribers
+         * @return `true` if all handlers were successfully unsubscribed, and `false` otherwise.
+         */
+        unsubscribe(subscribers: TracingChannelSubscribers<ContextType>): void;
+        /**
+         * Trace a synchronous function call. This will always produce a `start event` and `end event` around the execution and may produce an `error event` if the given function throws an error.
+         * This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.traceSync(() => {
+         *   // Do something
+         * }, {
+         *   some: 'thing',
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn Function to wrap a trace around
+         * @param context Shared object to correlate events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return The return value of the given function
+         */
+        traceSync<ThisArg = any, Args extends any[] = any[]>(
+            fn: (this: ThisArg, ...args: Args) => any,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): void;
+        /**
+         * Trace a promise-returning function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce an `asyncStart event` and `asyncEnd event` when a promise continuation is reached. It may also
+         * produce an `error event` if the given function throws an error or the
+         * returned promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.tracePromise(async () => {
+         *   // Do something
+         * }, {
+         *   some: 'thing',
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn Promise-returning function to wrap a trace around
+         * @param context Shared object to correlate trace events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return Chained from promise returned by the given function
+         */
+        tracePromise<ThisArg = any, Args extends any[] = any[]>(
+            fn: (this: ThisArg, ...args: Args) => Promise<any>,
+            context?: ContextType,
+            thisArg?: ThisArg,
+            ...args: Args
+        ): void;
+        /**
+         * Trace a callback-receiving function call. This will always produce a `start event` and `end event` around the synchronous portion of the
+         * function execution, and will produce a `asyncStart event` and `asyncEnd event` around the callback execution. It may also produce an `error event` if the given function throws an error or
+         * the returned
+         * promise rejects. This will run the given function using `channel.runStores(context, ...)` on the `start` channel which ensures all
+         * events should have any bound stores set to match this trace context.
+         *
+         * The `position` will be -1 by default to indicate the final argument should
+         * be used as the callback.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         *
+         * channels.traceCallback((arg1, callback) => {
+         *   // Do something
+         *   callback(null, 'result');
+         * }, 1, {
+         *   some: 'thing',
+         * }, thisArg, arg1, callback);
+         * ```
+         *
+         * The callback will also be run with `channel.runStores(context, ...)` which
+         * enables context loss recovery in some cases.
+         *
+         * ```js
+         * import diagnostics_channel from 'node:diagnostics_channel';
+         * import { AsyncLocalStorage } from 'node:async_hooks';
+         *
+         * const channels = diagnostics_channel.tracingChannel('my-channel');
+         * const myStore = new AsyncLocalStorage();
+         *
+         * // The start channel sets the initial store data to something
+         * // and stores that store data value on the trace context object
+         * channels.start.bindStore(myStore, (data) => {
+         *   const span = new Span(data);
+         *   data.span = span;
+         *   return span;
+         * });
+         *
+         * // Then asyncStart can restore from that data it stored previously
+         * channels.asyncStart.bindStore(myStore, (data) => {
+         *   return data.span;
+         * });
+         * ```
+         * @since v19.9.0
+         * @experimental
+         * @param fn callback using function to wrap a trace around
+         * @param position Zero-indexed argument position of expected callback
+         * @param context Shared object to correlate trace events through
+         * @param thisArg The receiver to be used for the function call
+         * @param args Optional arguments to pass to the function
+         * @return The return value of the given function
+         */
+        traceCallback<Fn extends (this: any, ...args: any) => any>(
+            fn: Fn,
+            position: number | undefined,
+            context: ContextType | undefined,
+            thisArg: any,
+            ...args: Parameters<Fn>
+        ): void;
     }
 }
 declare module "node:diagnostics_channel" {

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

@@ -281,7 +281,7 @@ declare module "fs" {
          * Asynchronously close the directory's underlying resource handle.
          * Subsequent reads will result in errors.
          *
-         * A promise is returned that will be resolved after the resource has been
+         * A promise is returned that will be fulfilled after the resource has been
          * closed.
          * @since v12.12.0
          */
@@ -296,7 +296,7 @@ declare module "fs" {
         /**
          * Asynchronously read the next directory entry via [`readdir(3)`](http://man7.org/linux/man-pages/man3/readdir.3.html) as an `fs.Dirent`.
          *
-         * A promise is returned that will be resolved with an `fs.Dirent`, or `null`if there are no more directory entries to read.
+         * A promise is returned that will be fulfilled with an `fs.Dirent`, or `null`if there are no more directory entries to read.
          *
          * Directory entries returned by this function are in no particular order as
          * provided by the operating system's underlying directory mechanisms.
@@ -354,31 +354,51 @@ declare module "fs" {
          * @since v0.5.8
          */
         close(): void;
+        /**
+         * When called, requests that the Node.js event loop _not_ exit so long as the `fs.FSWatcher` is active. Calling `watcher.ref()` multiple times will have
+         * no effect.
+         *
+         * By default, all `fs.FSWatcher` objects are "ref'ed", making it normally
+         * unnecessary to call `watcher.ref()` unless `watcher.unref()` had been
+         * called previously.
+         * @since v14.3.0, v12.20.0
+         */
+        ref(): this;
+        /**
+         * When called, the active `fs.FSWatcher` object will not require the Node.js
+         * event loop to remain active. If there is no other activity keeping the
+         * event loop running, the process may exit before the `fs.FSWatcher` object's
+         * callback is invoked. Calling `watcher.unref()` multiple times will have
+         * no effect.
+         * @since v14.3.0, v12.20.0
+         */
+        unref(): this;
         /**
          * events.EventEmitter
          *   1. change
-         *   2. error
+         *   2. close
+         *   3. error
          */
         addListener(event: string, listener: (...args: any[]) => void): this;
         addListener(event: "change", listener: (eventType: string, filename: string | Buffer) => void): this;
-        addListener(event: "error", listener: (error: Error) => 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 | Buffer) => void): this;
-        on(event: "error", listener: (error: Error) => 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 | Buffer) => void): this;
-        once(event: "error", listener: (error: Error) => 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 | Buffer) => void): this;
-        prependListener(event: "error", listener: (error: Error) => 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 | Buffer) => void): this;
-        prependOnceListener(event: "error", listener: (error: Error) => void): this;
         prependOnceListener(event: "close", listener: () => void): this;
+        prependOnceListener(event: "error", listener: (error: Error) => void): this;
     }
     /**
      * Instances of `fs.ReadStream` are created and returned using the {@link createReadStream} function.