node-red-contrib-tak-registration 0.13.0 → 0.14.0

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

@@ -609,11 +609,6 @@ declare module "crypto" {
          * @since v11.6.0
          */
         asymmetricKeyType?: KeyType | undefined;
-        /**
-         * For asymmetric keys, this property represents the size of the embedded key in
-         * bytes. This property is `undefined` for symmetric keys.
-         */
-        asymmetricKeySize?: number | undefined;
         /**
          * This property exists only on asymmetric keys. Depending on the type of the key,
          * this object contains information about the key. None of the information obtained
@@ -667,6 +662,19 @@ declare module "crypto" {
          * @since v11.6.0
          */
         symmetricKeySize?: number | undefined;
+        /**
+         * Converts a `KeyObject` instance to a `CryptoKey`.
+         * @since 22.10.0
+         */
+        toCryptoKey(
+            algorithm:
+                | webcrypto.AlgorithmIdentifier
+                | webcrypto.RsaHashedImportParams
+                | webcrypto.EcKeyImportParams
+                | webcrypto.HmacImportParams,
+            extractable: boolean,
+            keyUsages: readonly webcrypto.KeyUsage[],
+        ): webcrypto.CryptoKey;
         /**
          * Depending on the type of this `KeyObject`, this property is either`'secret'` for secret (symmetric) keys, `'public'` for public (asymmetric) keys
          * or `'private'` for private (asymmetric) keys.
@@ -2139,7 +2147,10 @@ declare module "crypto" {
      * be passed instead of a public key.
      * @since v0.11.14
      */
-    function publicEncrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+    function publicEncrypt(
+        key: RsaPublicKey | RsaPrivateKey | KeyLike,
+        buffer: NodeJS.ArrayBufferView | string,
+    ): Buffer;
     /**
      * Decrypts `buffer` with `key`.`buffer` was previously encrypted using
      * the corresponding private key, for example using {@link privateEncrypt}.
@@ -2151,7 +2162,10 @@ declare module "crypto" {
      * be passed instead of a public key.
      * @since v1.1.0
      */
-    function publicDecrypt(key: RsaPublicKey | RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+    function publicDecrypt(
+        key: RsaPublicKey | RsaPrivateKey | KeyLike,
+        buffer: NodeJS.ArrayBufferView | string,
+    ): Buffer;
     /**
      * Decrypts `buffer` with `privateKey`. `buffer` was previously encrypted using
      * the corresponding public key, for example using {@link publicEncrypt}.
@@ -2160,7 +2174,7 @@ declare module "crypto" {
      * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_OAEP_PADDING`.
      * @since v0.11.14
      */
-    function privateDecrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+    function privateDecrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): Buffer;
     /**
      * Encrypts `buffer` with `privateKey`. The returned data can be decrypted using
      * the corresponding public key, for example using {@link publicDecrypt}.
@@ -2169,7 +2183,7 @@ declare module "crypto" {
      * object, the `padding` property can be passed. Otherwise, this function uses `RSA_PKCS1_PADDING`.
      * @since v1.1.0
      */
-    function privateEncrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView): Buffer;
+    function privateEncrypt(privateKey: RsaPrivateKey | KeyLike, buffer: NodeJS.ArrayBufferView | string): Buffer;
     /**
      * ```js
      * const {
@@ -3648,11 +3662,21 @@ declare module "crypto" {
          * @since v15.6.0
          */
         readonly validFrom: string;
+        /**
+         * The date/time from which this certificate is valid, encapsulated in a `Date` object.
+         * @since v22.10.0
+         */
+        readonly validFromDate: Date;
         /**
          * The date/time until which this certificate is considered valid.
          * @since v15.6.0
          */
         readonly validTo: string;
+        /**
+         * The date/time until which this certificate is valid, encapsulated in a `Date` object.
+         * @since v22.10.0
+         */
+        readonly validToDate: Date;
         constructor(buffer: BinaryLike);
         /**
          * Checks whether the certificate matches the given email address.

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

@@ -304,12 +304,12 @@ declare module "events" {
             emitter: NodeJS.EventEmitter,
             eventName: string | symbol,
             options?: StaticEventEmitterIteratorOptions,
-        ): AsyncIterableIterator<any[]>;
+        ): NodeJS.AsyncIterator<any[]>;
         static on(
             emitter: EventTarget,
             eventName: string,
             options?: StaticEventEmitterIteratorOptions,
-        ): AsyncIterableIterator<any[]>;
+        ): NodeJS.AsyncIterator<any[]>;
         /**
          * A class method that returns the number of listeners for the given `eventName` registered on the given `emitter`.
          *
@@ -768,7 +768,7 @@ declare module "events" {
                 setMaxListeners(n: number): this;
                 /**
                  * Returns the current max listener value for the `EventEmitter` which is either
-                 * set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}.
+                 * set by `emitter.setMaxListeners(n)` or defaults to {@link EventEmitter.defaultMaxListeners}.
                  * @since v1.0.0
                  */
                 getMaxListeners(): number;

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

@@ -71,7 +71,7 @@ declare module "fs/promises" {
         length?: number | null;
         position?: number | null;
     }
-    interface CreateReadStreamOptions {
+    interface CreateReadStreamOptions extends Abortable {
         encoding?: BufferEncoding | null | undefined;
         autoClose?: boolean | undefined;
         emitClose?: boolean | undefined;
@@ -238,6 +238,10 @@ declare module "fs/promises" {
             length?: number | null,
             position?: number | null,
         ): Promise<FileReadResult<T>>;
+        read<T extends NodeJS.ArrayBufferView = Buffer>(
+            buffer: T,
+            options?: FileReadOptions<T>,
+        ): Promise<FileReadResult<T>>;
         read<T extends NodeJS.ArrayBufferView = Buffer>(options?: FileReadOptions<T>): Promise<FileReadResult<T>>;
         /**
          * Returns a `ReadableStream` that may be used to read the files data.
@@ -429,6 +433,13 @@ declare module "fs/promises" {
             bytesWritten: number;
             buffer: TBuffer;
         }>;
+        write<TBuffer extends Uint8Array>(
+            buffer: TBuffer,
+            options?: { offset?: number; length?: number; position?: number },
+        ): Promise<{
+            bytesWritten: number;
+            buffer: TBuffer;
+        }>;
         write(
             data: string,
             position?: number | null,
@@ -1245,19 +1256,19 @@ declare module "fs/promises" {
     /**
      * Retrieves the files matching the specified pattern.
      */
-    function glob(pattern: string | string[]): AsyncIterableIterator<string>;
+    function glob(pattern: string | string[]): NodeJS.AsyncIterator<string>;
     function glob(
         pattern: string | string[],
         opt: GlobOptionsWithFileTypes,
-    ): AsyncIterableIterator<Dirent>;
+    ): NodeJS.AsyncIterator<Dirent>;
     function glob(
         pattern: string | string[],
         opt: GlobOptionsWithoutFileTypes,
-    ): AsyncIterableIterator<string>;
+    ): NodeJS.AsyncIterator<string>;
     function glob(
         pattern: string | string[],
         opt: GlobOptions,
-    ): AsyncIterableIterator<Dirent> | AsyncIterableIterator<string>;
+    ): NodeJS.AsyncIterator<Dirent | string>;
 }
 declare module "node:fs/promises" {
     export * from "fs/promises";

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

@@ -284,7 +284,7 @@ declare module "fs" {
         /**
          * Asynchronously iterates over the directory via `readdir(3)` until all entries have been read.
          */
-        [Symbol.asyncIterator](): AsyncIterableIterator<Dirent>;
+        [Symbol.asyncIterator](): NodeJS.AsyncIterator<Dirent>;
         /**
          * Asynchronously close the directory's underlying resource handle.
          * Subsequent reads will result in errors.
@@ -4314,29 +4314,35 @@ declare module "fs" {
      */
     export function cpSync(source: string | URL, destination: string | URL, opts?: CopySyncOptions): void;
 
-    export interface GlobOptions {
+    interface GlobOptionsBase {
         /**
          * Current working directory.
          * @default process.cwd()
          */
         cwd?: string | undefined;
-        /**
-         * Function to filter out files/directories. Return true to exclude the item, false to include it.
-         */
-        exclude?: ((fileName: string) => boolean) | undefined;
         /**
          * `true` if the glob should return paths as `Dirent`s, `false` otherwise.
          * @default false
          * @since v22.2.0
          */
         withFileTypes?: boolean | undefined;
+        /**
+         * Function to filter out files/directories. Return true to exclude the item, false to include it.
+         */
+        exclude?: ((fileName: any) => boolean) | undefined;
     }
-    export interface GlobOptionsWithFileTypes extends GlobOptions {
+    export interface GlobOptionsWithFileTypes extends GlobOptionsBase {
+        exclude?: ((fileName: Dirent) => boolean) | undefined;
         withFileTypes: true;
     }
-    export interface GlobOptionsWithoutFileTypes extends GlobOptions {
+    export interface GlobOptionsWithoutFileTypes extends GlobOptionsBase {
+        exclude?: ((fileName: string) => boolean) | undefined;
         withFileTypes?: false | undefined;
     }
+    export interface GlobOptions extends GlobOptionsBase {
+        exclude?: ((fileName: Dirent | string) => boolean) | undefined;
+    }
+
     /**
      * Retrieves the files matching the specified pattern.
      */

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

@@ -156,6 +156,8 @@ declare global {
     interface RequireResolve extends NodeJS.RequireResolve {}
     interface NodeModule extends NodeJS.Module {}
 
+    var global: typeof globalThis;
+
     var process: NodeJS.Process;
     var console: Console;
 
@@ -247,71 +249,26 @@ declare global {
         };
 
     /**
-     * A browser-compatible implementation of [`localStorage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage).
-     * Data is stored unencrypted in the file specified by the `--localstorage-file` CLI flag.
+     * A browser-compatible implementation of [`localStorage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage). Data is stored
+     * unencrypted in the file specified by the `--localstorage-file` CLI flag.
+     * The maximum amount of data that can be stored is 10 MB.
      * Any modification of this data outside of the Web Storage API is not supported.
      * Enable this API with the `--experimental-webstorage` CLI flag.
+     * `localStorage` data is not stored per user or per request when used in the context
+     * of a server, it is shared across all users and requests.
      * @since v22.4.0
      */
     var localStorage: Storage;
 
     /**
-     * A browser-compatible implementation of [`sessionStorage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage).
-     * Data is stored in memory, with a storage quota of 10 MB.
-     * Any modification of this data outside of the Web Storage API is not supported.
-     * Enable this API with the `--experimental-webstorage` CLI flag.
+     * A browser-compatible implementation of [`sessionStorage`](https://developer.mozilla.org/en-US/docs/Web/API/Window/sessionStorage). Data is stored in
+     * memory, with a storage quota of 10 MB. `sessionStorage` data persists only within
+     * the currently running process, and is not shared between workers.
      * @since v22.4.0
      */
     var sessionStorage: Storage;
     // #endregion Storage
 
-    // #region Disposable
-    interface SymbolConstructor {
-        /**
-         * A method that is used to release resources held by an object. Called by the semantics of the `using` statement.
-         */
-        readonly dispose: unique symbol;
-
-        /**
-         * A method that is used to asynchronously release resources held by an object. Called by the semantics of the `await using` statement.
-         */
-        readonly asyncDispose: unique symbol;
-    }
-
-    interface Disposable {
-        [Symbol.dispose](): void;
-    }
-
-    interface AsyncDisposable {
-        [Symbol.asyncDispose](): PromiseLike<void>;
-    }
-    // #endregion Disposable
-
-    // #region ArrayLike.at()
-    interface RelativeIndexable<T> {
-        /**
-         * Takes an integer value and returns the item at that index,
-         * allowing for positive and negative integers.
-         * Negative integers count back from the last item in the array.
-         */
-        at(index: number): T | undefined;
-    }
-    interface String extends RelativeIndexable<string> {}
-    interface Array<T> extends RelativeIndexable<T> {}
-    interface ReadonlyArray<T> extends RelativeIndexable<T> {}
-    interface Int8Array extends RelativeIndexable<number> {}
-    interface Uint8Array extends RelativeIndexable<number> {}
-    interface Uint8ClampedArray extends RelativeIndexable<number> {}
-    interface Int16Array extends RelativeIndexable<number> {}
-    interface Uint16Array extends RelativeIndexable<number> {}
-    interface Int32Array extends RelativeIndexable<number> {}
-    interface Uint32Array extends RelativeIndexable<number> {}
-    interface Float32Array extends RelativeIndexable<number> {}
-    interface Float64Array extends RelativeIndexable<number> {}
-    interface BigInt64Array extends RelativeIndexable<bigint> {}
-    interface BigUint64Array extends RelativeIndexable<bigint> {}
-    // #endregion ArrayLike.at() end
-
     /**
      * @since v17.0.0
      *
@@ -464,7 +421,7 @@ declare global {
             unpipe(destination?: WritableStream): this;
             unshift(chunk: string | Uint8Array, encoding?: BufferEncoding): void;
             wrap(oldStream: ReadableStream): this;
-            [Symbol.asyncIterator](): AsyncIterableIterator<string | Buffer>;
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<string | Buffer>;
         }
 
         interface WritableStream extends EventEmitter {
@@ -533,6 +490,20 @@ declare global {
         interface ReadOnlyDict<T> {
             readonly [key: string]: T | undefined;
         }
+
+        /** An iterable iterator returned by the Node.js API. */
+        // Default TReturn/TNext in v22 is `any`, for compatibility with the previously-used IterableIterator.
+        // TODO: In next major @types/node version, change default TReturn to undefined.
+        interface Iterator<T, TReturn = any, TNext = any> extends IteratorObject<T, TReturn, TNext> {
+            [Symbol.iterator](): NodeJS.Iterator<T, TReturn, TNext>;
+        }
+
+        /** An async iterable iterator returned by the Node.js API. */
+        // Default TReturn/TNext in v22 is `any`, for compatibility with the previously-used AsyncIterableIterator.
+        // TODO: In next major @types/node version, change default TReturn to undefined.
+        interface AsyncIterator<T, TReturn = any, TNext = any> extends AsyncIteratorObject<T, TReturn, TNext> {
+            [Symbol.asyncIterator](): NodeJS.AsyncIterator<T, TReturn, TNext>;
+        }
     }
 
     interface RequestInit extends _RequestInit {}

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

@@ -141,6 +141,7 @@ declare module "http" {
         "content-range"?: string | undefined;
         "content-security-policy"?: string | undefined;
         "content-security-policy-report-only"?: string | undefined;
+        "content-type"?: string | undefined;
         cookie?: string | string[] | undefined;
         dav?: string | string[] | undefined;
         dnt?: string | undefined;
@@ -161,7 +162,7 @@ declare module "http" {
         location?: string | undefined;
         "max-forwards"?: string | undefined;
         origin?: string | undefined;
-        prgama?: string | string[] | undefined;
+        pragma?: string | string[] | undefined;
         "proxy-authenticate"?: string | string[] | undefined;
         "proxy-authorization"?: string | undefined;
         "public-key-pins"?: string | undefined;
@@ -588,6 +589,42 @@ declare module "http" {
          * @param value Header value
          */
         setHeader(name: string, value: number | string | readonly string[]): this;
+        /**
+         * Sets multiple header values for implicit headers. headers must be an instance of
+         * `Headers` or `Map`, if a header already exists in the to-be-sent headers, its
+         * value will be replaced.
+         *
+         * ```js
+         * const headers = new Headers({ foo: 'bar' });
+         * outgoingMessage.setHeaders(headers);
+         * ```
+         *
+         * or
+         *
+         * ```js
+         * const headers = new Map([['foo', 'bar']]);
+         * outgoingMessage.setHeaders(headers);
+         * ```
+         *
+         * When headers have been set with `outgoingMessage.setHeaders()`, they will be
+         * merged with any headers passed to `response.writeHead()`, with the headers passed
+         * to `response.writeHead()` given precedence.
+         *
+         * ```js
+         * // Returns content-type = text/plain
+         * const server = http.createServer((req, res) => {
+         *   const headers = new Headers({ 'Content-Type': 'text/html' });
+         *   res.setHeaders(headers);
+         *   res.writeHead(200, { 'Content-Type': 'text/plain' });
+         *   res.end('ok');
+         * });
+         * ```
+         *
+         * @since v19.6.0, v18.15.0
+         * @param name Header name
+         * @param value Header value
+         */
+        setHeaders(headers: Headers | Map<string, number | string | readonly string[]>): this;
         /**
          * Append a single header value to the header object.
          *

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

@@ -1269,7 +1269,10 @@ declare module "http2" {
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,
         Http2Request extends typeof Http2ServerRequest = typeof Http2ServerRequest,
         Http2Response extends typeof Http2ServerResponse<InstanceType<Http2Request>> = typeof Http2ServerResponse,
-    > extends ServerSessionOptions<Http1Request, Http1Response, Http2Request, Http2Response> {}
+    > extends ServerSessionOptions<Http1Request, Http1Response, Http2Request, Http2Response> {
+        streamResetBurst?: number | undefined;
+        streamResetRate?: number | undefined;
+    }
     export interface SecureServerOptions<
         Http1Request extends typeof IncomingMessage = typeof IncomingMessage,
         Http1Response extends typeof ServerResponse<InstanceType<Http1Request>> = typeof ServerResponse,

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

@@ -21,7 +21,6 @@ declare module "https" {
             servername?: string | undefined; // SNI TLS Extension
         };
     interface AgentOptions extends http.AgentOptions, tls.ConnectionOptions {
-        rejectUnauthorized?: boolean | undefined;
         maxCachedSessions?: number | undefined;
     }
     /**

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

@@ -22,22 +22,22 @@
  * IN THE SOFTWARE.
  */
 
-// NOTE: These definitions support NodeJS and TypeScript 5.7+.
+// NOTE: These definitions support Node.js and TypeScript 5.7+.
 
-// Reference required types from the default lib:
+// Reference required TypeScript libs:
 /// <reference lib="es2020" />
-/// <reference lib="esnext.asynciterable" />
-/// <reference lib="esnext.intl" />
-/// <reference lib="esnext.bigint" />
 
-// Definitions specific to TypeScript 4.9 through 5.7+
+// TypeScript backwards-compatibility definitions:
+/// <reference path="compatibility/index.d.ts" />
+
+// Definitions specific to TypeScript 5.7+:
 /// <reference path="globals.typedarray.d.ts" />
 /// <reference path="buffer.buffer.d.ts" />
 
-// Base definitions for all NodeJS modules that are not specific to any version of TypeScript:
+// Definitions for Node.js modules that are not specific to any version of TypeScript:
+/// <reference path="globals.d.ts" />
 /// <reference path="assert.d.ts" />
 /// <reference path="assert/strict.d.ts" />
-/// <reference path="globals.d.ts" />
 /// <reference path="async_hooks.d.ts" />
 /// <reference path="buffer.d.ts" />
 /// <reference path="child_process.d.ts" />
@@ -90,5 +90,3 @@
 /// <reference path="wasi.d.ts" />
 /// <reference path="worker_threads.d.ts" />
 /// <reference path="zlib.d.ts" />
-
-/// <reference path="globals.global.d.ts" />

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

@@ -48,7 +48,7 @@ declare module "module" {
          * @since v13.7.0, v12.17.0
          * @return Returns `module.SourceMap` if a source map is found, `undefined` otherwise.
          */
-        function findSourceMap(path: string, error?: Error): SourceMap;
+        function findSourceMap(path: string, error?: Error): SourceMap | undefined;
         interface SourceMapPayload {
             file: string;
             version: number;
@@ -125,7 +125,14 @@ declare module "module" {
         interface ImportAttributes extends NodeJS.Dict<string> {
             type?: string | undefined;
         }
-        type ModuleFormat = "builtin" | "commonjs" | "json" | "module" | "wasm";
+        type ModuleFormat =
+            | "builtin"
+            | "commonjs"
+            | "commonjs-typescript"
+            | "json"
+            | "module"
+            | "module-typescript"
+            | "wasm";
         type ModuleSource = string | ArrayBuffer | NodeJS.TypedArray;
         interface GlobalPreloadContext {
             port: MessagePort;
@@ -196,7 +203,7 @@ declare module "module" {
             context: ResolveHookContext,
             nextResolve: (
                 specifier: string,
-                context?: ResolveHookContext,
+                context?: Partial<ResolveHookContext>,
             ) => ResolveFnOutput | Promise<ResolveFnOutput>,
         ) => ResolveFnOutput | Promise<ResolveFnOutput>;
         interface LoadHookContext {
@@ -236,14 +243,68 @@ declare module "module" {
         type LoadHook = (
             url: string,
             context: LoadHookContext,
-            nextLoad: (url: string, context?: LoadHookContext) => LoadFnOutput | Promise<LoadFnOutput>,
+            nextLoad: (url: string, context?: Partial<LoadHookContext>) => LoadFnOutput | Promise<LoadFnOutput>,
         ) => LoadFnOutput | Promise<LoadFnOutput>;
+        namespace constants {
+            /**
+             * The following constants are returned as the `status` field in the object returned by
+             * {@link enableCompileCache} to indicate the result of the attempt to enable the
+             * [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache).
+             * @since v22.8.0
+             */
+            namespace compileCacheStatus {
+                /**
+                 * Node.js has enabled the compile cache successfully. The directory used to store the
+                 * compile cache will be returned in the `directory` field in the
+                 * returned object.
+                 */
+                const ENABLED: number;
+                /**
+                 * The compile cache has already been enabled before, either by a previous call to
+                 * {@link enableCompileCache}, or by the `NODE_COMPILE_CACHE=dir`
+                 * environment variable. The directory used to store the
+                 * compile cache will be returned in the `directory` field in the
+                 * returned object.
+                 */
+                const ALREADY_ENABLED: number;
+                /**
+                 * Node.js fails to enable the compile cache. This can be caused by the lack of
+                 * permission to use the specified directory, or various kinds of file system errors.
+                 * The detail of the failure will be returned in the `message` field in the
+                 * returned object.
+                 */
+                const FAILED: number;
+                /**
+                 * Node.js cannot enable the compile cache because the environment variable
+                 * `NODE_DISABLE_COMPILE_CACHE=1` has been set.
+                 */
+                const DISABLED: number;
+            }
+        }
     }
     interface RegisterOptions<Data> {
         parentURL: string | URL;
         data?: Data | undefined;
         transferList?: any[] | undefined;
     }
+    interface EnableCompileCacheResult {
+        /**
+         * One of the {@link constants.compileCacheStatus}
+         */
+        status: number;
+        /**
+         * If Node.js cannot enable the compile cache, this contains
+         * the error message. Only set if `status` is `module.constants.compileCacheStatus.FAILED`.
+         */
+        message?: string;
+        /**
+         * If the compile cache is enabled, this contains the directory
+         * where the compile cache is stored. Only set if  `status` is
+         * `module.constants.compileCacheStatus.ENABLED` or
+         * `module.constants.compileCacheStatus.ALREADY_ENABLED`.
+         */
+        directory?: string;
+    }
     interface Module extends NodeModule {}
     class Module {
         static runMain(): void;
@@ -258,6 +319,53 @@ declare module "module" {
             options?: RegisterOptions<Data>,
         ): void;
         static register<Data = any>(specifier: string | URL, options?: RegisterOptions<Data>): void;
+        /**
+         * Enable [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache)
+         * in the current Node.js instance.
+         *
+         * If `cacheDir` is not specified, Node.js will either use the directory specified by the
+         * `NODE_COMPILE_CACHE=dir` environment variable if it's set, or use
+         * `path.join(os.tmpdir(), 'node-compile-cache')` otherwise. For general use cases, it's
+         * recommended to call `module.enableCompileCache()` without specifying the `cacheDir`,
+         * so that the directory can be overridden by the `NODE_COMPILE_CACHE` environment
+         * variable when necessary.
+         *
+         * Since compile cache is supposed to be a quiet optimization that is not required for the
+         * application to be functional, this method is designed to not throw any exception when the
+         * compile cache cannot be enabled. Instead, it will return an object containing an error
+         * message in the `message` field to aid debugging.
+         * If compile cache is enabled successfully, the `directory` field in the returned object
+         * contains the path to the directory where the compile cache is stored. The `status`
+         * field in the returned object would be one of the `module.constants.compileCacheStatus`
+         * values to indicate the result of the attempt to enable the
+         * [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache).
+         *
+         * This method only affects the current Node.js instance. To enable it in child worker threads,
+         * either call this method in child worker threads too, or set the
+         * `process.env.NODE_COMPILE_CACHE` value to compile cache directory so the behavior can
+         * be inherited into the child workers. The directory can be obtained either from the
+         * `directory` field returned by this method, or with {@link getCompileCacheDir}.
+         * @since v22.8.0
+         * @param cacheDir Optional path to specify the directory where the compile cache
+         * will be stored/retrieved.
+         */
+        static enableCompileCache(cacheDir?: string): EnableCompileCacheResult;
+        /**
+         * @since v22.8.0
+         * @return Path to the [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache)
+         * directory if it is enabled, or `undefined` otherwise.
+         */
+        static getCompileCacheDir(): string | undefined;
+        /**
+         * Flush the [module compile cache](https://nodejs.org/docs/latest-v22.x/api/module.html#module-compile-cache)
+         * accumulated from modules already loaded
+         * in the current Node.js instance to disk. This returns after all the flushing
+         * file system operations come to an end, no matter they succeed or not. If there
+         * are any errors, this will fail silently, since compile cache misses should not
+         * interfere with the actual operation of the application.
+         * @since v22.10.0
+         */
+        static flushCompileCache(): void;
         constructor(id: string, parent?: Module);
     }
     global {

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

@@ -896,6 +896,9 @@ declare module "net" {
     function getDefaultAutoSelectFamily(): boolean;
     /**
      * Sets the default value of the `autoSelectFamily` option of `socket.connect(options)`.
+     * @param value The new default value.
+     * The initial default value is `true`, unless the command line option
+     * `--no-network-family-autoselection` is provided.
      * @since v19.4.0
      */
     function setDefaultAutoSelectFamily(value: boolean): void;