@cloudflare/workers-types 4.20251223.0 → 4.20251225.0

package/2021-11-03/index.d.ts

@@ -2508,6 +2508,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2526,8 +2528,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2820,13 +2820,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2021-11-03/index.ts

@@ -2516,6 +2516,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2534,8 +2536,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2828,13 +2828,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-01-31/index.d.ts

@@ -2515,6 +2515,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2533,8 +2535,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2827,13 +2827,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-01-31/index.ts

@@ -2523,6 +2523,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2541,8 +2543,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2835,13 +2835,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-03-21/index.d.ts

@@ -2523,6 +2523,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2541,8 +2543,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2835,13 +2835,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-03-21/index.ts

@@ -2531,6 +2531,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2549,8 +2551,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2843,13 +2843,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-08-04/index.d.ts

@@ -2524,6 +2524,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2542,8 +2544,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2836,13 +2836,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-08-04/index.ts

@@ -2532,6 +2532,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2550,8 +2552,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2844,13 +2844,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-10-31/index.d.ts

@@ -2524,6 +2524,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2542,8 +2544,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2836,13 +2836,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-10-31/index.ts

@@ -2532,6 +2532,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2550,8 +2552,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2844,13 +2844,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-11-30/index.d.ts

@@ -2529,6 +2529,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2547,8 +2549,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2841,13 +2841,13 @@ declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2022-11-30/index.ts

@@ -2537,6 +2537,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2555,8 +2557,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2849,13 +2849,13 @@ export declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2023-03-01/index.d.ts

@@ -2535,6 +2535,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2553,8 +2555,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2847,13 +2847,13 @@ declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2023-03-01/index.ts

@@ -2543,6 +2543,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2561,8 +2563,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2855,13 +2855,13 @@ export declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2023-07-01/index.d.ts

@@ -2535,6 +2535,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2553,8 +2555,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2847,13 +2847,13 @@ declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/2023-07-01/index.ts

@@ -2543,6 +2543,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2561,8 +2563,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2855,13 +2855,13 @@ export declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/experimental/index.d.ts

@@ -2641,6 +2641,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2659,8 +2661,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2953,13 +2953,13 @@ declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/experimental/index.ts

@@ -2649,6 +2649,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2667,8 +2669,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2961,13 +2961,13 @@ export declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/index.d.ts

@@ -2508,6 +2508,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2526,8 +2528,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2820,13 +2820,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/index.ts

@@ -2516,6 +2516,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2534,8 +2536,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2828,13 +2828,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/latest/index.d.ts

@@ -2545,6 +2545,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2563,8 +2565,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2857,13 +2857,13 @@ declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/latest/index.ts

@@ -2553,6 +2553,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2571,8 +2573,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2865,13 +2865,13 @@ export declare abstract class TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/oldest/index.d.ts

@@ -2508,6 +2508,8 @@ interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2526,8 +2528,6 @@ interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 type ReadableStreamReadResult<R = any> =
@@ -2820,13 +2820,13 @@ interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/oldest/index.ts

@@ -2516,6 +2516,8 @@ export interface Transformer<I = any, O = any> {
   expectedLength?: number;
 }
 export interface StreamPipeOptions {
+  preventAbort?: boolean;
+  preventCancel?: boolean;
   /**
    * Pipes this readable stream to a given writable stream destination. The way in which the piping process behaves under various error conditions can be customized with a number of passed options. It returns a promise that fulfills when the piping process completes successfully, or rejects if any errors were encountered.
    *
@@ -2534,8 +2536,6 @@ export interface StreamPipeOptions {
    * The signal option can be set to an AbortSignal to allow aborting an ongoing pipe operation via the corresponding AbortController. In this case, this source readable stream will be canceled, and destination aborted, unless the respective options preventCancel or preventAbort are set.
    */
   preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
   signal?: AbortSignal;
 }
 export type ReadableStreamReadResult<R = any> =
@@ -2828,13 +2828,13 @@ export interface TransformStreamDefaultController<O = any> {
   terminate(): void;
 }
 export interface ReadableWritablePair<R = any, W = any> {
+  readable: ReadableStream<R>;
   /**
    * Provides a convenient, chainable way of piping this readable stream through a transform stream (or any other { writable, readable } pair). It simply pipes the stream into the writable side of the supplied pair, and returns the readable side for further use.
    *
    * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
    */
   writable: WritableStream<W>;
-  readable: ReadableStream<R>;
 }
 /**
  * The **`WritableStream`** interface of the Streams API provides a standard abstraction for writing streaming data to a destination, known as a sink.

package/package.json

@@ -7,5 +7,5 @@
   },
   "author": "Cloudflare Workers DevProd Team <workers-devprod@cloudflare.com> (https://workers.cloudflare.com)",
   "license": "MIT OR Apache-2.0",
-  "version": "4.20251223.0"
+  "version": "4.20251225.0"
 }