@chainlink/external-adapter-framework 2.13.0 → 2.13.2

package/generator-adapter/node_modules/@types/node/module.d.ts

@@ -80,37 +80,48 @@ declare module "module" {
              */
             directory?: string;
         }
+        interface EnableCompileCacheOptions {
+            /**
+             * Optional. Directory to store the compile cache. If not specified, the directory specified by
+             * the [`NODE_COMPILE_CACHE=dir`](https://nodejs.org/docs/latest-v24.x/api/cli.html#node_compile_cachedir)
+             * environment variable will be used if it's set, or `path.join(os.tmpdir(), 'node-compile-cache')` otherwise.
+             * @since v24.12.0
+             */
+            directory?: string | undefined;
+            /**
+             * Optional. If `true`, enables portable compile cache so that the cache can be reused even if the project directory
+             * is moved. This is a best-effort feature. If not specified, it will depend on whether the environment variable
+             * [NODE_COMPILE_CACHE_PORTABLE=1](https://nodejs.org/docs/latest-v24.x/api/cli.html#node_compile_cache_portable1) is set.
+             * @since v24.12.0
+             */
+            portable?: boolean | undefined;
+        }
         /**
          * Enable [module compile cache](https://nodejs.org/docs/latest-v24.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
+         * For general use cases, it's recommended to call `module.enableCompileCache()` without specifying the
+         * `options.directory`, 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
+         * Since compile cache is supposed to be a optimization that is not mission critical, 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-v24.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}.
+         * `directory` field returned by this method, or with {@link getCompileCacheDir `module.getCompileCacheDir()`}.
          * @since v22.8.0
-         * @param cacheDir Optional path to specify the directory where the compile cache
+         * @param options Optional. If a string is passed, it is considered to be `options.directory`.
          * will be stored/retrieved.
          */
-        function enableCompileCache(cacheDir?: string): EnableCompileCacheResult;
+        function enableCompileCache(options?: string | EnableCompileCacheOptions): EnableCompileCacheResult;
         /**
          * Flush the [module compile cache](https://nodejs.org/docs/latest-v24.x/api/module.html#module-compile-cache)
          * accumulated from modules already loaded

package/generator-adapter/node_modules/@types/node/net.d.ts

@@ -105,9 +105,14 @@ declare module "net" {
          * See `Writable` stream `write()` method for more
          * information.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          */
         write(buffer: Uint8Array | string, cb?: (err?: Error | null) => void): boolean;
+        /**
+         * Sends data on the socket, with an explicit encoding for string data.
+         * @see {@link Socket.write} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         */
         write(str: Uint8Array | string, encoding?: BufferEncoding, cb?: (err?: Error | null) => void): boolean;
         /**
          * Initiate a connection on a given socket.
@@ -347,12 +352,26 @@ declare module "net" {
          *
          * See `writable.end()` for further details.
          * @since v0.1.90
-         * @param [encoding='utf8'] Only used when data is `string`.
          * @param callback Optional callback for when the socket is finished.
          * @return The socket itself.
          */
         end(callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(buffer: Uint8Array | string, callback?: () => void): this;
+        /**
+         * Half-closes the socket, with one final chunk of data.
+         * @see {@link Socket.end} for full details.
+         * @since v0.1.90
+         * @param [encoding='utf8'] Only used when data is `string`.
+         * @param callback Optional callback for when the socket is finished.
+         * @return The socket itself.
+         */
         end(str: Uint8Array | string, encoding?: BufferEncoding, callback?: () => void): this;
         /**
          * events.EventEmitter

package/generator-adapter/node_modules/@types/node/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/node",
-    "version": "24.10.13",
+    "version": "24.12.2",
     "description": "TypeScript definitions for node",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/node",
     "license": "MIT",
@@ -150,6 +150,6 @@
         "undici-types": "~7.16.0"
     },
     "peerDependencies": {},
-    "typesPublisherContentHash": "2ec3065bf306401d19db2ee65619ca53b48d5461db1133c7eeb53d407b8dcbc8",
-    "typeScriptVersion": "5.2"
+    "typesPublisherContentHash": "d7203ff42f0a932fc10105074ec5f78418782e8d306c14cb314ce869dff07f43",
+    "typeScriptVersion": "5.3"
 }

package/generator-adapter/node_modules/@types/node/perf_hooks.d.ts

@@ -200,14 +200,6 @@ declare module "perf_hooks" {
         active: number;
         utilization: number;
     }
-    /**
-     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
-     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
-     */
-    type EventLoopUtilityFunction = (
-        utilization1?: EventLoopUtilization,
-        utilization2?: EventLoopUtilization,
-    ) => EventLoopUtilization;
     interface MarkOptions {
         /**
          * Additional optional detail to include with the mark.
@@ -264,11 +256,19 @@ declare module "perf_hooks" {
          */
         clearResourceTimings(name?: string): void;
         /**
-         * eventLoopUtilization is similar to CPU utilization except that it is calculated using high precision wall-clock time.
-         * It represents the percentage of time the event loop has spent outside the event loop's event provider (e.g. epoll_wait).
-         * No other CPU idle time is taken into consideration.
+         * This is an alias of `perf_hooks.eventLoopUtilization()`.
+         *
+         * _This property is an extension by Node.js. It is not available in Web browsers._
+         * @since v14.10.0, v12.19.0
+         * @param utilization1 The result of a previous call to
+         * `eventLoopUtilization()`.
+         * @param utilization2 The result of a previous call to
+         * `eventLoopUtilization()` prior to `utilization1`.
          */
-        eventLoopUtilization: EventLoopUtilityFunction;
+        eventLoopUtilization(
+            utilization1?: EventLoopUtilization,
+            utilization2?: EventLoopUtilization,
+        ): EventLoopUtilization;
         /**
          * Returns a list of `PerformanceEntry` objects in chronological order with respect to `performanceEntry.startTime`.
          * If you are only interested in performance entries of certain types or that have certain names, see
@@ -371,41 +371,12 @@ declare module "perf_hooks" {
          */
         readonly timeOrigin: number;
         /**
-         * _This property is an extension by Node.js. It is not available in Web browsers._
-         *
-         * Wraps a function within a new function that measures the running time of the wrapped function.
-         * A `PerformanceObserver` must be subscribed to the `'function'` event type in order for the timing details to be accessed.
-         *
-         * ```js
-         * import {
-         *   performance,
-         *   PerformanceObserver,
-         * } from 'node:perf_hooks';
-         *
-         * function someFunction() {
-         *   console.log('hello world');
-         * }
-         *
-         * const wrapped = performance.timerify(someFunction);
-         *
-         * const obs = new PerformanceObserver((list) => {
-         *   console.log(list.getEntries()[0].duration);
-         *
-         *   performance.clearMarks();
-         *   performance.clearMeasures();
-         *   obs.disconnect();
-         * });
-         * obs.observe({ entryTypes: ['function'] });
-         *
-         * // A performance timeline entry will be created
-         * wrapped();
-         * ```
+         * This is an alias of `perf_hooks.timerify()`.
          *
-         * If the wrapped function returns a promise, a finally handler will be attached to the promise and the duration will be reported
-         * once the finally handler is invoked.
-         * @param fn
+         * _This property is an extension by Node.js. It is not available in Web browsers._
+         * @since v8.5.0
          */
-        timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
+        timerify<T extends (...args: any[]) => any>(fn: T, options?: TimerifyOptions): T;
         /**
          * An object which is JSON representation of the performance object. It is similar to
          * [`window.performance.toJSON`](https://developer.mozilla.org/en-US/docs/Web/API/Performance/toJSON) in browsers.
@@ -844,6 +815,83 @@ declare module "perf_hooks" {
          */
         add(other: RecordableHistogram): void;
     }
+    interface CreateHistogramOptions {
+        /**
+         * The lowest discernible value. Must be an integer value greater than 0.
+         * @default 1
+         */
+        lowest?: number | bigint | undefined;
+        /**
+         * The highest recordable value. Must be an integer value that is equal to
+         * or greater than two times `lowest`.
+         * @default Number.MAX_SAFE_INTEGER
+         */
+        highest?: number | bigint | undefined;
+        /**
+         * The number of accuracy digits. Must be a number between `1` and `5`.
+         * @default 3
+         */
+        figures?: number | undefined;
+    }
+    /**
+     * Returns a {@link RecordableHistogram `RecordableHistogram`}.
+     * @since v15.9.0, v14.18.0
+     */
+    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+    /**
+     * The `eventLoopUtilization()` function returns an object that contains the
+     * cumulative duration of time the event loop has been both idle and active as a
+     * high resolution milliseconds timer. The `utilization` value is the calculated
+     * Event Loop Utilization (ELU).
+     *
+     * If bootstrapping has not yet finished on the main thread the properties have
+     * the value of `0`. The ELU is immediately available on
+     * [Worker threads](https://nodejs.org/docs/latest-v24.x/api/worker_threads.html#worker-threads)
+     * since bootstrap happens within the event loop.
+     *
+     * Both `utilization1` and `utilization2` are optional parameters.
+     *
+     * If `utilization1` is passed, then the delta between the current call's `active`
+     * and `idle` times, as well as the corresponding `utilization` value are
+     * calculated and returned (similar to `process.hrtime()`).
+     *
+     * If `utilization1` and `utilization2` are both passed, then the delta is
+     * calculated between the two arguments. This is a convenience option because,
+     * unlike `process.hrtime()`, calculating the ELU is more complex than a
+     * single subtraction.
+     *
+     * ELU is similar to CPU utilization, except that it only measures event loop
+     * statistics and not CPU usage. It represents the percentage of time the event
+     * loop has spent outside the event loop's event provider (e.g. `epoll_wait`).
+     * No other CPU idle time is taken into consideration. The following is an example
+     * of how a mostly idle process will have a high ELU.
+     *
+     * ```js
+     * import { eventLoopUtilization } from 'node:perf_hooks';
+     * import { spawnSync } from 'node:child_process';
+     *
+     * setImmediate(() => {
+     *   const elu = eventLoopUtilization();
+     *   spawnSync('sleep', ['5']);
+     *   console.log(eventLoopUtilization(elu).utilization);
+     * });
+     * ```
+     *
+     * Although the CPU is mostly idle while running this script, the value of `utilization`
+     * is `1`. This is because the call to `child_process.spawnSync()` blocks the event loop
+     * from proceeding.
+     *
+     * Passing in a user-defined object instead of the result of a previous call to
+     * `eventLoopUtilization()` will lead to undefined behavior. The return values are not
+     * guaranteed to reflect any correct state of the event loop.
+     * @since v24.12.0
+     * @param utilization1 The result of a previous call to `eventLoopUtilization()`.
+     * @param utilization2 The result of a previous call to `eventLoopUtilization()` prior to `utilization1`.
+     */
+    function eventLoopUtilization(
+        utilization1?: EventLoopUtilization,
+        utilization2?: EventLoopUtilization,
+    ): EventLoopUtilization;
     /**
      * _This property is an extension by Node.js. It is not available in Web browsers._
      *
@@ -873,28 +921,40 @@ declare module "perf_hooks" {
      * @since v11.10.0
      */
     function monitorEventLoopDelay(options?: EventLoopMonitorOptions): IntervalHistogram;
-    interface CreateHistogramOptions {
-        /**
-         * The minimum recordable value. Must be an integer value greater than 0.
-         * @default 1
-         */
-        lowest?: number | bigint | undefined;
-        /**
-         * The maximum recordable value. Must be an integer value greater than min.
-         * @default Number.MAX_SAFE_INTEGER
-         */
-        highest?: number | bigint | undefined;
-        /**
-         * The number of accuracy digits. Must be a number between 1 and 5.
-         * @default 3
-         */
-        figures?: number | undefined;
-    }
     /**
-     * Returns a `RecordableHistogram`.
-     * @since v15.9.0, v14.18.0
+     * _This property is an extension by Node.js. It is not available in Web browsers._
+     *
+     * Wraps a function within a new function that measures the running time of the
+     * wrapped function. A `PerformanceObserver` must be subscribed to the `'function'`
+     * event type in order for the timing details to be accessed.
+     *
+     * ```js
+     * import { timerify, performance, PerformanceObserver } from 'node:perf_hooks';
+     *
+     * function someFunction() {
+     *   console.log('hello world');
+     * }
+     *
+     * const wrapped = timerify(someFunction);
+     *
+     * const obs = new PerformanceObserver((list) => {
+     *   console.log(list.getEntries()[0].duration);
+     *
+     *   performance.clearMarks();
+     *   performance.clearMeasures();
+     *   obs.disconnect();
+     * });
+     * obs.observe({ entryTypes: ['function'] });
+     *
+     * // A performance timeline entry will be created
+     * wrapped();
+     * ```
+     *
+     * If the wrapped function returns a promise, a finally handler will be attached
+     * to the promise and the duration will be reported once the finally handler is invoked.
+     * @since v24.12.0
      */
-    function createHistogram(options?: CreateHistogramOptions): RecordableHistogram;
+    function timerify<T extends (...params: any[]) => any>(fn: T, options?: TimerifyOptions): T;
     import {
         performance as _performance,
         PerformanceEntry as _PerformanceEntry,

package/generator-adapter/node_modules/@types/node/process.d.ts

@@ -235,7 +235,7 @@ declare module "process" {
                 /**
                  * A value that is `"strip"` by default,
                  * `"transform"` if Node.js is run with `--experimental-transform-types`, and `false` if
-                 * Node.js is run with `--no-experimental-strip-types`.
+                 * Node.js is run with `--no-strip-types`.
                  * @since v22.10.0
                  */
                 readonly typescript: "strip" | "transform" | false;
@@ -344,12 +344,7 @@ declare module "process" {
                 isTTY?: true | undefined;
             }
             // Alias for compatibility
-            interface ProcessEnv extends Dict<string> {
-                /**
-                 * Can be used to change the default timezone at runtime
-                 */
-                TZ?: string | undefined;
-            }
+            interface ProcessEnv extends Dict<string> {}
             interface HRTime {
                 /**
                  * This is the legacy version of {@link process.hrtime.bigint()}

package/generator-adapter/node_modules/@types/node/sqlite.d.ts

@@ -6,12 +6,7 @@
  * import sqlite from 'node:sqlite';
  * ```
  *
- * This module is only available under the `node:` scheme. The following will not
- * work:
- *
- * ```js
- * import sqlite from 'sqlite';
- * ```
+ * This module is only available under the `node:` scheme.
  *
  * The following example shows the basic usage of the `node:sqlite` module to open
  * an in-memory database, write data to the database, and then read the data back.
@@ -123,6 +118,14 @@ declare module "node:sqlite" {
          * @default false
          */
         allowUnknownNamedParameters?: boolean | undefined;
+        /**
+         * If `true`, enables the defensive flag. When the defensive flag is enabled,
+         * language features that allow ordinary SQL to deliberately corrupt the database
+         * file are disabled. The defensive flag can also be set using `enableDefensive()`.
+         * @since v24.12.0
+         * @default true
+         */
+        defensive?: boolean | undefined;
     }
     interface CreateSessionOptions {
         /**
@@ -294,6 +297,16 @@ declare module "node:sqlite" {
          * @param allow Whether to allow loading extensions.
          */
         enableLoadExtension(allow: boolean): void;
+        /**
+         * Enables or disables the defensive flag. When the defensive flag is active,
+         * language features that allow ordinary SQL to deliberately corrupt the
+         * database file are disabled.
+         * See [`SQLITE_DBCONFIG_DEFENSIVE`](https://www.sqlite.org/c3ref/c_dbconfig_defensive.html#sqlitedbconfigdefensive)
+         * in the SQLite documentation for details.
+         * @since v24.12.0
+         * @param active Whether to set the defensive flag.
+         */
+        enableDefensive(active: boolean): void;
         /**
          * This method is a wrapper around [`sqlite3_db_filename()`](https://sqlite.org/c3ref/db_filename.html)
          * @since v24.0.0
@@ -413,7 +426,7 @@ declare module "node:sqlite" {
          */
         prepare(sql: string): StatementSync;
         /**
-         * Creates a new `SQLTagStore`, which is an LRU (Least Recently Used) cache for
+         * Creates a new {@link SQLTagStore `SQLTagStore`}, which is an LRU (Least Recently Used) cache for
          * storing prepared statements. This allows for the efficient reuse of prepared
          * statements by tagging them with a unique identifier.
          *
@@ -427,7 +440,7 @@ declare module "node:sqlite" {
          * import { DatabaseSync } from 'node:sqlite';
          *
          * const db = new DatabaseSync(':memory:');
-         * const sql = db.createSQLTagStore();
+         * const sql = db.createTagStore();
          *
          * db.exec('CREATE TABLE users (id INT, name TEXT)');
          *
@@ -450,6 +463,7 @@ declare module "node:sqlite" {
          * // ]
          * ```
          * @since v24.9.0
+         * @param maxSize The maximum number of prepared statements to cache. **Default**: `1000`.
          * @returns A new SQL tag store for caching prepared statements.
          */
         createTagStore(maxSize?: number): SQLTagStore;
@@ -468,6 +482,8 @@ declare module "node:sqlite" {
          * [`sqlite3changeset_apply()`](https://www.sqlite.org/session/sqlite3changeset_apply.html).
          *
          * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
          * const sourceDb = new DatabaseSync(':memory:');
          * const targetDb = new DatabaseSync(':memory:');
          *
@@ -525,19 +541,24 @@ declare module "node:sqlite" {
          * [`sqlite3session_delete()`](https://www.sqlite.org/session/sqlite3session_delete.html).
          */
         close(): void;
+        /**
+         * Closes the session. If the session is already closed, does nothing.
+         * @since v24.9.0
+         */
+        [Symbol.dispose](): void;
     }
     /**
      * This class represents a single LRU (Least Recently Used) cache for storing
      * prepared statements.
      *
-     * Instances of this class are created via the database.createSQLTagStore() method,
+     * Instances of this class are created via the database.createTagStore() method,
      * not by using a constructor. The store caches prepared statements based on the
      * provided SQL query string. When the same query is seen again, the store
      * retrieves the cached statement and safely applies the new values through
      * parameter binding, thereby preventing attacks like SQL injection.
      *
      * The cache has a maxSize that defaults to 1000 statements, but a custom size can
-     * be provided (e.g., database.createSQLTagStore(100)). All APIs exposed by this
+     * be provided (e.g., database.createTagStore(100)). All APIs exposed by this
      * class execute synchronously.
      * @since v24.9.0
      */

package/generator-adapter/node_modules/@types/node/stream/web.d.ts

@@ -105,7 +105,7 @@ declare module "stream/web" {
     }
     interface ReadableStreamReadDoneResult<T> {
         done: true;
-        value?: T;
+        value: T | undefined;
     }
     type ReadableStreamReadResult<T> = ReadableStreamReadValueResult<T> | ReadableStreamReadDoneResult<T>;
     interface ReadableByteStreamControllerCallback {
@@ -250,7 +250,7 @@ declare module "stream/web" {
     interface ReadableStreamDefaultController<R = any> {
         readonly desiredSize: number | null;
         close(): void;
-        enqueue(chunk?: R): void;
+        enqueue(chunk: R): void;
         error(e?: any): void;
     }
     const ReadableStreamDefaultController: {
@@ -279,7 +279,7 @@ declare module "stream/web" {
     };
     interface TransformStreamDefaultController<O = any> {
         readonly desiredSize: number | null;
-        enqueue(chunk?: O): void;
+        enqueue(chunk: O): void;
         error(reason?: any): void;
         terminate(): void;
     }
@@ -315,7 +315,7 @@ declare module "stream/web" {
         abort(reason?: any): Promise<void>;
         close(): Promise<void>;
         releaseLock(): void;
-        write(chunk?: W): Promise<void>;
+        write(chunk: W): Promise<void>;
     }
     const WritableStreamDefaultWriter: {
         prototype: WritableStreamDefaultWriter;
@@ -339,7 +339,7 @@ declare module "stream/web" {
         size?: QueuingStrategySize<T>;
     }
     interface QueuingStrategySize<T = any> {
-        (chunk?: T): number;
+        (chunk: T): number;
     }
     interface QueuingStrategyInit {
         /**

package/generator-adapter/node_modules/@types/node/stream.d.ts

@@ -863,11 +863,20 @@ declare module "stream" {
              * @since v0.9.4
              * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
              * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
-             * @param [encoding='utf8'] The encoding, if `chunk` is a string.
              * @param callback Callback for when this chunk of data is flushed.
              * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
              */
             write(chunk: any, callback?: (error: Error | null | undefined) => void): boolean;
+            /**
+             * Writes data to the stream, with an explicit encoding for string data.
+             * @see {@link Writable.write} for full details.
+             * @since v0.9.4
+             * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
+             * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
+             * @param encoding The encoding, if `chunk` is a string.
+             * @param callback Callback for when this chunk of data is flushed.
+             * @return `false` if the stream wishes for the calling code to wait for the `'drain'` event to be emitted before continuing to write additional data; otherwise `true`.
+             */
             write(chunk: any, encoding: BufferEncoding, callback?: (error: Error | null | undefined) => void): boolean;
             /**
              * The `writable.setDefaultEncoding()` method sets the default `encoding` for a `Writable` stream.
@@ -892,13 +901,27 @@ declare module "stream" {
              * // Writing more now is not allowed!
              * ```
              * @since v0.9.4
+             * @param cb Callback for when the stream is finished.
+             */
+            end(cb?: () => void): this;
+            /**
+             * Signals that no more data will be written, with one final chunk of data.
+             * @see {@link Writable.end} for full details.
+             * @since v0.9.4
              * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
              * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
-             * @param encoding The encoding if `chunk` is a string
-             * @param callback Callback for when the stream is finished.
+             * @param cb Callback for when the stream is finished.
              */
-            end(cb?: () => void): this;
             end(chunk: any, cb?: () => void): this;
+            /**
+             * Signals that no more data will be written, with one final chunk of data.
+             * @see {@link Writable.end} for full details.
+             * @since v0.9.4
+             * @param chunk Optional data to write. For streams not operating in object mode, `chunk` must be a {string}, {Buffer},
+             * {TypedArray} or {DataView}. For object mode streams, `chunk` may be any JavaScript value other than `null`.
+             * @param encoding The encoding if `chunk` is a string
+             * @param cb Callback for when the stream is finished.
+             */
             end(chunk: any, encoding: BufferEncoding, cb?: () => void): this;
             /**
              * The `writable.cork()` method forces all written data to be buffered in memory.

package/generator-adapter/node_modules/@types/node/tls.d.ts

@@ -15,31 +15,31 @@ declare module "tls" {
     import * as stream from "stream";
     const CLIENT_RENEG_LIMIT: number;
     const CLIENT_RENEG_WINDOW: number;
-    interface Certificate {
+    interface Certificate extends NodeJS.Dict<string | string[]> {
         /**
          * Country code.
          */
-        C: string;
+        C?: string | string[];
         /**
          * Street.
          */
-        ST: string;
+        ST?: string | string[];
         /**
          * Locality.
          */
-        L: string;
+        L?: string | string[];
         /**
          * Organization.
          */
-        O: string;
+        O?: string | string[];
         /**
          * Organizational unit.
          */
-        OU: string;
+        OU?: string | string[];
         /**
          * Common name.
          */
-        CN: string;
+        CN?: string | string[];
     }
     interface PeerCertificate {
         /**

package/generator-adapter/node_modules/@types/node/url.d.ts

@@ -80,7 +80,7 @@ declare module "url" {
      * function getURL(req) {
      *   const proto = req.headers['x-forwarded-proto'] || 'https';
      *   const host = req.headers['x-forwarded-host'] || req.headers.host || 'example.com';
-     *   return new URL(req.url || '/', `${proto}://${host}`);
+     *   return new URL(`${proto}://${host}${req.url || '/'}`);
      * }
      * ```
      *
@@ -90,7 +90,7 @@ declare module "url" {
      *
      * ```js
      * function getURL(req) {
-     *   return new URL(req.url || '/', 'https://example.com');
+     *   return new URL(`https://example.com${req.url || '/'}`);
      * }
      * ```
      * @since v0.1.25