@idlebox/stripe-node-types 24.0.14 → 24.0.15

package/sqlite.d.ts

@@ -55,14 +55,13 @@
  * ```
  * @since v22.5.0
  * @experimental
- * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/sqlite.js)
+ * @see [source](https://github.com/nodejs/node/blob/v25.x/lib/sqlite.js)
  */
 
 declare module "node:sqlite" {
+    import { PathLike } from '_not-use-node-type_fs';
     type SQLInputValue = null | number | bigint | string | NodeJS.ArrayBufferView;
-    type SQLOutputValue = null | number | bigint | string | Uint8Array;
-    /** @deprecated Use `SQLInputValue` or `SQLOutputValue` instead. */
-    type SupportedValueType = SQLOutputValue;
+    type SQLOutputValue = null | number | bigint | string | NodeJS.NonSharedUint8Array;
     interface DatabaseSyncOptions {
         /**
          * If `true`, the database is opened by the constructor. When
@@ -113,6 +112,33 @@ declare module "node:sqlite" {
          * @default 0
          */
         timeout?: number | undefined;
+        /**
+         * If `true`, integer fields are read as JavaScript `BigInt` values. If `false`,
+         * integer fields are read as JavaScript numbers.
+         * @since v24.4.0
+         * @default false
+         */
+        readBigInts?: boolean | undefined;
+        /**
+         * If `true`, query results are returned as arrays instead of objects.
+         * @since v24.4.0
+         * @default false
+         */
+        returnArrays?: boolean | undefined;
+        /**
+         * If `true`, allows binding named parameters without the prefix
+         * character (e.g., `foo` instead of `:foo`).
+         * @since v24.4.40
+         * @default true
+         */
+        allowBareNamedParameters?: boolean | undefined;
+        /**
+         * If `true`, unknown named parameters are ignored when binding.
+         * If `false`, an exception is thrown for unknown named parameters.
+         * @since v24.4.40
+         * @default false
+         */
+        allowUnknownNamedParameters?: boolean | undefined;
     }
     interface CreateSessionOptions {
         /**
@@ -229,7 +255,7 @@ declare module "node:sqlite" {
          * To use an in-memory database, the path should be the special name `':memory:'`.
          * @param options Configuration options for the database connection.
          */
-        constructor(path: string | Buffer | URL, options?: DatabaseSyncOptions);
+        constructor(path: PathLike, options?: DatabaseSyncOptions);
         /**
          * Registers a new aggregate function with the SQLite database. This method is a wrapper around
          * [`sqlite3_create_window_function()`](https://www.sqlite.org/c3ref/create_function.html).
@@ -310,7 +336,7 @@ declare module "node:sqlite" {
          * @param func The JavaScript function to call when the SQLite
          * function is invoked. The return value of this function should be a valid
          * SQLite data type: see
-         * [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v24.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite).
+         * [Type conversion between JavaScript and SQLite](https://nodejs.org/docs/latest-v25.x/api/sqlite.html#type-conversion-between-javascript-and-sqlite).
          * The result defaults to `NULL` if the return value is `undefined`.
          */
         function(
@@ -319,6 +345,64 @@ declare module "node:sqlite" {
             func: (...args: SQLOutputValue[]) => SQLInputValue,
         ): void;
         function(name: string, func: (...args: SQLOutputValue[]) => SQLInputValue): void;
+        /**
+         * Sets an authorizer callback that SQLite will invoke whenever it attempts to
+         * access data or modify the database schema through prepared statements.
+         * This can be used to implement security policies, audit access, or restrict certain operations.
+         * This method is a wrapper around [`sqlite3_set_authorizer()`](https://sqlite.org/c3ref/set_authorizer.html).
+         *
+         * When invoked, the callback receives five arguments:
+         *
+         * * `actionCode` {number} The type of operation being performed (e.g.,
+         *   `SQLITE_INSERT`, `SQLITE_UPDATE`, `SQLITE_SELECT`).
+         * * `arg1` {string|null} The first argument (context-dependent, often a table name).
+         * * `arg2` {string|null} The second argument (context-dependent, often a column name).
+         * * `dbName` {string|null} The name of the database.
+         * * `triggerOrView` {string|null} The name of the trigger or view causing the access.
+         *
+         * The callback must return one of the following constants:
+         *
+         * * `SQLITE_OK` - Allow the operation.
+         * * `SQLITE_DENY` - Deny the operation (causes an error).
+         * * `SQLITE_IGNORE` - Ignore the operation (silently skip).
+         *
+         * ```js
+         * import { DatabaseSync, constants } from 'node:sqlite';
+         * const db = new DatabaseSync(':memory:');
+         *
+         * // Set up an authorizer that denies all table creation
+         * db.setAuthorizer((actionCode) => {
+         *   if (actionCode === constants.SQLITE_CREATE_TABLE) {
+         *     return constants.SQLITE_DENY;
+         *   }
+         *   return constants.SQLITE_OK;
+         * });
+         *
+         * // This will work
+         * db.prepare('SELECT 1').get();
+         *
+         * // This will throw an error due to authorization denial
+         * try {
+         *   db.exec('CREATE TABLE blocked (id INTEGER)');
+         * } catch (err) {
+         *   console.log('Operation blocked:', err.message);
+         * }
+         * ```
+         * @since v24.10.0
+         * @param callback The authorizer function to set, or `null` to
+         * clear the current authorizer.
+         */
+        setAuthorizer(
+            callback:
+                | ((
+                    actionCode: number,
+                    arg1: string | null,
+                    arg2: string | null,
+                    dbName: string | null,
+                    triggerOrView: string | null,
+                ) => number)
+                | null,
+        ): void;
         /**
          * Whether the database is currently open or not.
          * @since v22.15.0
@@ -344,6 +428,47 @@ declare module "node:sqlite" {
          * @return The prepared statement.
          */
         prepare(sql: string): StatementSync;
+        /**
+         * Creates a new `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.
+         *
+         * When a tagged SQL literal is executed, the `SQLTagStore` checks if a prepared
+         * statement for that specific SQL string already exists in the cache. If it does,
+         * the cached statement is used. If not, a new prepared statement is created,
+         * executed, and then stored in the cache for future use. This mechanism helps to
+         * avoid the overhead of repeatedly parsing and preparing the same SQL statements.
+         *
+         * ```js
+         * import { DatabaseSync } from 'node:sqlite';
+         *
+         * const db = new DatabaseSync(':memory:');
+         * const sql = db.createSQLTagStore();
+         *
+         * db.exec('CREATE TABLE users (id INT, name TEXT)');
+         *
+         * // Using the 'run' method to insert data.
+         * // The tagged literal is used to identify the prepared statement.
+         * sql.run`INSERT INTO users VALUES (1, 'Alice')`;
+         * sql.run`INSERT INTO users VALUES (2, 'Bob')`;
+         *
+         * // Using the 'get' method to retrieve a single row.
+         * const id = 1;
+         * const user = sql.get`SELECT * FROM users WHERE id = ${id}`;
+         * console.log(user); // { id: 1, name: 'Alice' }
+         *
+         * // Using the 'all' method to retrieve all rows.
+         * const allUsers = sql.all`SELECT * FROM users ORDER BY id`;
+         * console.log(allUsers);
+         * // [
+         * //   { id: 1, name: 'Alice' },
+         * //   { id: 2, name: 'Bob' }
+         * // ]
+         * ```
+         * @since v24.9.0
+         * @returns A new SQL tag store for caching prepared statements.
+         */
+        createTagStore(maxSize?: number): SQLTagStore;
         /**
          * Creates and attaches a session to the database. This method is a wrapper around
          * [`sqlite3session_create()`](https://www.sqlite.org/session/sqlite3session_create.html) and
@@ -385,7 +510,6 @@ declare module "node:sqlite" {
          * Closes the database connection. If the database connection is already closed
          * then this is a no-op.
          * @since v22.15.0
-         * @experimental
          */
         [Symbol.dispose](): void;
     }
@@ -400,7 +524,7 @@ declare module "node:sqlite" {
          * @returns Binary changeset that can be applied to other databases.
          * @since v22.12.0
          */
-        changeset(): Uint8Array;
+        changeset(): NodeJS.NonSharedUint8Array;
         /**
          * Similar to the method above, but generates a more compact patchset. See
          * [Changesets and Patchsets](https://www.sqlite.org/sessionintro.html#changesets_and_patchsets)
@@ -410,7 +534,7 @@ declare module "node:sqlite" {
          * @returns Binary patchset that can be applied to other databases.
          * @since v22.12.0
          */
-        patchset(): Uint8Array;
+        patchset(): NodeJS.NonSharedUint8Array;
         /**
          * Closes the session. An exception is thrown if the database or the session is not open. This method is a
          * wrapper around
@@ -418,6 +542,73 @@ declare module "node:sqlite" {
          */
         close(): 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,
+     * 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
+     * class execute synchronously.
+     * @since v24.9.0
+     */
+    interface SQLTagStore {
+        /**
+         * Executes the given SQL query and returns all resulting rows as an array of objects.
+         * @since v24.9.0
+         */
+        all(
+            stringElements: TemplateStringsArray,
+            ...boundParameters: SQLInputValue[]
+        ): Record<string, SQLOutputValue>[];
+        /**
+         * Executes the given SQL query and returns the first resulting row as an object.
+         * @since v24.9.0
+         */
+        get(
+            stringElements: TemplateStringsArray,
+            ...boundParameters: SQLInputValue[]
+        ): Record<string, SQLOutputValue> | undefined;
+        /**
+         * Executes the given SQL query and returns an iterator over the resulting rows.
+         * @since v24.9.0
+         */
+        iterate(
+            stringElements: TemplateStringsArray,
+            ...boundParameters: SQLInputValue[]
+        ): NodeJS.Iterator<Record<string, SQLOutputValue>>;
+        /**
+         * Executes the given SQL query, which is expected to not return any rows (e.g., INSERT, UPDATE, DELETE).
+         * @since v24.9.0
+         */
+        run(stringElements: TemplateStringsArray, ...boundParameters: SQLInputValue[]): StatementResultingChanges;
+        /**
+         * A read-only property that returns the number of prepared statements currently in the cache.
+         * @since v24.9.0
+         * @returns The maximum number of prepared statements the cache can hold.
+         */
+        size(): number;
+        /**
+         * A read-only property that returns the maximum number of prepared statements the cache can hold.
+         * @since v24.9.0
+         */
+        readonly capacity: number;
+        /**
+         * A read-only property that returns the `DatabaseSync` object associated with this `SQLTagStore`.
+         * @since v24.9.0
+         */
+        readonly db: DatabaseSync;
+        /**
+         * Resets the LRU cache, clearing all stored prepared statements.
+         * @since v24.9.0
+         */
+        clear(): void;
+    }
     interface StatementColumnMetadata {
         /**
          * The unaliased name of the column in the origin
@@ -583,6 +774,13 @@ declare module "node:sqlite" {
          * @param enabled Enables or disables support for unknown named parameters.
          */
         setAllowUnknownNamedParameters(enabled: boolean): void;
+        /**
+         * When enabled, query results returned by the `all()`, `get()`, and `iterate()` methods will be returned as arrays instead
+         * of objects.
+         * @since v24.0.0
+         * @param enabled Enables or disables the return of query results as arrays.
+         */
+        setReturnArrays(enabled: boolean): void;
         /**
          * When reading from the database, SQLite `INTEGER`s are mapped to JavaScript
          * numbers by default. However, SQLite `INTEGER`s can store values larger than
@@ -620,8 +818,9 @@ declare module "node:sqlite" {
          */
         rate?: number | undefined;
         /**
-         * Callback function that will be called with the number of pages copied and the total number of
-         * pages.
+         * An optional callback function that will be called after each backup step. The argument passed
+         * to this callback is an `Object` with `remainingPages` and `totalPages` properties, describing the current progress
+         * of the backup operation.
          */
         progress?: ((progressInfo: BackupProgressInfo) => void) | undefined;
     }
@@ -658,9 +857,10 @@ declare module "node:sqlite" {
      * the contents will be overwritten.
      * @param options Optional configuration for the backup. The
      * following properties are supported:
-     * @returns A promise that resolves when the backup is completed and rejects if an error occurs.
+     * @returns A promise that fulfills with the total number of backed-up pages upon completion, or rejects if an
+     * error occurs.
      */
-    function backup(sourceDb: DatabaseSync, path: string | Buffer | URL, options?: BackupOptions): Promise<void>;
+    function backup(sourceDb: DatabaseSync, path: PathLike, options?: BackupOptions): Promise<number>;
     /**
      * @since v22.13.0
      */
@@ -700,5 +900,54 @@ declare module "node:sqlite" {
          * @since v22.12.0
          */
         const SQLITE_CHANGESET_ABORT: number;
+        /**
+         * Deny the operation and cause an error to be returned.
+         * @since v24.10.0
+         */
+        const SQLITE_DENY: number;
+        /**
+         * Ignore the operation and continue as if it had never been requested.
+         * @since 24.10.0
+         */
+        const SQLITE_IGNORE: number;
+        /**
+         * Allow the operation to proceed normally.
+         * @since v24.10.0
+         */
+        const SQLITE_OK: number;
+        const SQLITE_CREATE_INDEX: number;
+        const SQLITE_CREATE_TABLE: number;
+        const SQLITE_CREATE_TEMP_INDEX: number;
+        const SQLITE_CREATE_TEMP_TABLE: number;
+        const SQLITE_CREATE_TEMP_TRIGGER: number;
+        const SQLITE_CREATE_TEMP_VIEW: number;
+        const SQLITE_CREATE_TRIGGER: number;
+        const SQLITE_CREATE_VIEW: number;
+        const SQLITE_DELETE: number;
+        const SQLITE_DROP_INDEX: number;
+        const SQLITE_DROP_TABLE: number;
+        const SQLITE_DROP_TEMP_INDEX: number;
+        const SQLITE_DROP_TEMP_TABLE: number;
+        const SQLITE_DROP_TEMP_TRIGGER: number;
+        const SQLITE_DROP_TEMP_VIEW: number;
+        const SQLITE_DROP_TRIGGER: number;
+        const SQLITE_DROP_VIEW: number;
+        const SQLITE_INSERT: number;
+        const SQLITE_PRAGMA: number;
+        const SQLITE_READ: number;
+        const SQLITE_SELECT: number;
+        const SQLITE_TRANSACTION: number;
+        const SQLITE_UPDATE: number;
+        const SQLITE_ATTACH: number;
+        const SQLITE_DETACH: number;
+        const SQLITE_ALTER_TABLE: number;
+        const SQLITE_REINDEX: number;
+        const SQLITE_ANALYZE: number;
+        const SQLITE_CREATE_VTABLE: number;
+        const SQLITE_DROP_VTABLE: number;
+        const SQLITE_FUNCTION: number;
+        const SQLITE_SAVEPOINT: number;
+        const SQLITE_COPY: number;
+        const SQLITE_RECURSIVE: number;
     }
 }

package/stream/consumers.d.ts

@@ -20,32 +20,32 @@
  */
 
 declare module "node:stream/consumers" {
-    import { Blob as NodeBlob } from 'node:buffer';
-    import { ReadableStream as WebReadableStream } from 'node:stream/web';
+    import { Blob, NonSharedBuffer } from 'node:buffer';
+    import { ReadableStream } from 'node:stream/web';
     /**
      * @since v16.7.0
      * @returns Fulfills with an `ArrayBuffer` containing the full contents of the stream.
      */
-    function arrayBuffer(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
+    function arrayBuffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<ArrayBuffer>;
     /**
      * @since v16.7.0
      * @returns Fulfills with a `Blob` containing the full contents of the stream.
      */
-    function blob(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NodeBlob>;
+    function blob(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Blob>;
     /**
      * @since v16.7.0
      * @returns Fulfills with a `Buffer` containing the full contents of the stream.
      */
-    function buffer(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<Buffer>;
+    function buffer(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<NonSharedBuffer>;
     /**
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a
      * UTF-8 encoded string that is then passed through `JSON.parse()`.
      */
-    function json(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
+    function json(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<unknown>;
     /**
      * @since v16.7.0
      * @returns Fulfills with the contents of the stream parsed as a UTF-8 encoded string.
      */
-    function text(stream: WebReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<string>;
+    function text(stream: ReadableStream | NodeJS.ReadableStream | AsyncIterable<any>): Promise<string>;
 }

package/stream/promises.d.ts

@@ -15,14 +15,14 @@
 
 
 declare module "node:stream/promises" {
+    import { Abortable } from 'node:events';
     import {
         FinishedOptions as _FinishedOptions,
         PipelineDestination,
-        PipelineOptions,
-        PipelinePromise,
         PipelineSource,
         PipelineTransform,
     } from 'node:stream';
+    import { ReadableStream, WritableStream } from 'node:stream/web';
     interface FinishedOptions extends _FinishedOptions {
         /**
          * If true, removes the listeners registered by this function before the promise is fulfilled.
@@ -30,15 +30,130 @@ declare module "node:stream/promises" {
          */
         cleanup?: boolean | undefined;
     }
+    /**
+     * ```js
+     * import { finished } from 'node:stream/promises';
+     * import { createReadStream } from 'node:fs';
+     *
+     * const rs = createReadStream('archive.tar');
+     *
+     * async function run() {
+     *   await finished(rs);
+     *   console.log('Stream is done reading.');
+     * }
+     *
+     * run().catch(console.error);
+     * rs.resume(); // Drain the stream.
+     * ```
+     *
+     * The `finished` API also provides a [callback version](https://nodejs.org/docs/latest-v25.x/api/stream.html#streamfinishedstream-options-callback).
+     *
+     * `stream.finished()` leaves dangling event listeners (in particular
+     * `'error'`, `'end'`, `'finish'` and `'close'`) after the returned promise is
+     * resolved or rejected. The reason for this is so that unexpected `'error'`
+     * events (due to incorrect stream implementations) do not cause unexpected
+     * crashes. If this is unwanted behavior then `options.cleanup` should be set to
+     * `true`:
+     *
+     * ```js
+     * await finished(rs, { cleanup: true });
+     * ```
+     * @since v15.0.0
+     * @returns Fulfills when the stream is no longer readable or writable.
+     */
     function finished(
-        stream: NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream,
+        stream: NodeJS.ReadableStream | NodeJS.WritableStream | ReadableStream | WritableStream,
         options?: FinishedOptions,
     ): Promise<void>;
+    interface PipelineOptions extends Abortable {
+        end?: boolean | undefined;
+    }
+    type PipelineResult<S extends PipelineDestination<any, any>> = S extends (...args: any[]) => PromiseLike<infer R>
+        ? Promise<R>
+        : Promise<void>;
+    /**
+     * ```js
+     * import { pipeline } from 'node:stream/promises';
+     * import { createReadStream, createWriteStream } from 'node:fs';
+     * import { createGzip } from 'node:zlib';
+     *
+     * await pipeline(
+     *   createReadStream('archive.tar'),
+     *   createGzip(),
+     *   createWriteStream('archive.tar.gz'),
+     * );
+     * console.log('Pipeline succeeded.');
+     * ```
+     *
+     * To use an `AbortSignal`, pass it inside an options object, as the last argument.
+     * When the signal is aborted, `destroy` will be called on the underlying pipeline,
+     * with an `AbortError`.
+     *
+     * ```js
+     * import { pipeline } from 'node:stream/promises';
+     * import { createReadStream, createWriteStream } from 'node:fs';
+     * import { createGzip } from 'node:zlib';
+     *
+     * const ac = new AbortController();
+     * const { signal } = ac;
+     * setImmediate(() => ac.abort());
+     * try {
+     *   await pipeline(
+     *     createReadStream('archive.tar'),
+     *     createGzip(),
+     *     createWriteStream('archive.tar.gz'),
+     *     { signal },
+     *   );
+     * } catch (err) {
+     *   console.error(err); // AbortError
+     * }
+     * ```
+     *
+     * The `pipeline` API also supports async generators:
+     *
+     * ```js
+     * import { pipeline } from 'node:stream/promises';
+     * import { createReadStream, createWriteStream } from 'node:fs';
+     *
+     * await pipeline(
+     *   createReadStream('lowercase.txt'),
+     *   async function* (source, { signal }) {
+     *     source.setEncoding('utf8');  // Work with strings rather than `Buffer`s.
+     *     for await (const chunk of source) {
+     *       yield await processChunk(chunk, { signal });
+     *     }
+     *   },
+     *   createWriteStream('uppercase.txt'),
+     * );
+     * console.log('Pipeline succeeded.');
+     * ```
+     *
+     * Remember to handle the `signal` argument passed into the async generator.
+     * Especially in the case where the async generator is the source for the
+     * pipeline (i.e. first argument) or the pipeline will never complete.
+     *
+     * ```js
+     * import { pipeline } from 'node:stream/promises';
+     * import fs from 'node:fs';
+     * await pipeline(
+     *   async function* ({ signal }) {
+     *     await someLongRunningfn({ signal });
+     *     yield 'asd';
+     *   },
+     *   fs.createWriteStream('uppercase.txt'),
+     * );
+     * console.log('Pipeline succeeded.');
+     * ```
+     *
+     * The `pipeline` API provides [callback version](https://nodejs.org/docs/latest-v25.x/api/stream.html#streampipelinesource-transforms-destination-callback):
+     * @since v15.0.0
+     * @returns Fulfills when the pipeline is complete.
+     */
     function pipeline<A extends PipelineSource<any>, B extends PipelineDestination<A, any>>(
         source: A,
         destination: B,
         options?: PipelineOptions,
-    ): PipelinePromise<B>;
+    ): PipelineResult<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -48,7 +163,7 @@ declare module "node:stream/promises" {
         transform1: T1,
         destination: B,
         options?: PipelineOptions,
-    ): PipelinePromise<B>;
+    ): PipelineResult<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -60,7 +175,7 @@ declare module "node:stream/promises" {
         transform2: T2,
         destination: B,
         options?: PipelineOptions,
-    ): PipelinePromise<B>;
+    ): PipelineResult<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -74,7 +189,7 @@ declare module "node:stream/promises" {
         transform3: T3,
         destination: B,
         options?: PipelineOptions,
-    ): PipelinePromise<B>;
+    ): PipelineResult<B>;
     function pipeline<
         A extends PipelineSource<any>,
         T1 extends PipelineTransform<A, any>,
@@ -90,14 +205,20 @@ declare module "node:stream/promises" {
         transform4: T4,
         destination: B,
         options?: PipelineOptions,
-    ): PipelinePromise<B>;
+    ): PipelineResult<B>;
     function pipeline(
-        streams: ReadonlyArray<NodeJS.ReadableStream | NodeJS.WritableStream | NodeJS.ReadWriteStream>,
+        streams: readonly [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>],
         options?: PipelineOptions,
     ): Promise<void>;
     function pipeline(
-        stream1: NodeJS.ReadableStream,
-        stream2: NodeJS.ReadWriteStream | NodeJS.WritableStream,
-        ...streams: Array<NodeJS.ReadWriteStream | NodeJS.WritableStream | PipelineOptions>
+        ...streams: [PipelineSource<any>, ...PipelineTransform<any, any>[], PipelineDestination<any, any>]
+    ): Promise<void>;
+    function pipeline(
+        ...streams: [
+            PipelineSource<any>,
+            ...PipelineTransform<any, any>[],
+            PipelineDestination<any, any>,
+            options: PipelineOptions,
+        ]
     ): Promise<void>;
 }