@cloudflare/workers-types 4.20250403.0 → 4.20250404.0

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

@@ -1253,7 +1253,7 @@ declare class DigestStream extends WritableStream<
   ArrayBuffer | ArrayBufferView
 > {
   constructor(algorithm: string | SubtleCryptoHashAlgorithm);
-  readonly digest: Promise<ArrayBuffer | ArrayBufferView>;
+  readonly digest: Promise<ArrayBuffer>;
   get bytesWritten(): number | bigint;
 }
 /**
@@ -1262,7 +1262,7 @@ declare class DigestStream extends WritableStream<
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder)
  */
 declare class TextDecoder {
-  constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  constructor(label?: string, options?: TextDecoderConstructorOptions);
   /**
    * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
    *
@@ -3072,7 +3072,7 @@ interface GPUCommandEncoder {
     destinationOffset: number | bigint,
     size: number | bigint,
   ): void;
-  finish(param0?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+  finish(param1?: GPUCommandBufferDescriptor): GPUCommandBuffer;
   copyTextureToBuffer(
     source: GPUImageCopyTexture,
     destination: GPUImageCopyBuffer,
@@ -6147,19 +6147,7 @@ declare namespace Rpc {
   //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
   type Serializable<T> =
     // Structured cloneables
-    | void
-    | undefined
-    | null
-    | boolean
-    | number
-    | bigint
-    | string
-    | TypedArray
-    | ArrayBuffer
-    | DataView
-    | Date
-    | Error
-    | RegExp
+    | BaseType
     // Structured cloneable composites
     | Map<
         T extends Map<infer U, unknown> ? Serializable<U> : never,
@@ -6171,11 +6159,6 @@ declare namespace Rpc {
         [K in keyof T]: K extends number | string ? Serializable<T[K]> : never;
       }
     // Special types
-    | ReadableStream<Uint8Array>
-    | WritableStream<Uint8Array>
-    | Request
-    | Response
-    | Headers
     | Stub<Stubable>
     // Serialized as stubs, see `Stubify`
     | Stubable;
@@ -6186,6 +6169,26 @@ declare namespace Rpc {
     dup(): this;
   }
   export type Stub<T extends Stubable> = Provider<T> & StubBase<T>;
+  // This represents all the types that can be sent as-is over an RPC boundary
+  type BaseType =
+    | void
+    | undefined
+    | null
+    | boolean
+    | number
+    | bigint
+    | string
+    | TypedArray
+    | ArrayBuffer
+    | DataView
+    | Date
+    | Error
+    | RegExp
+    | ReadableStream<Uint8Array>
+    | WritableStream<Uint8Array>
+    | Request
+    | Response
+    | Headers;
   // Recursively rewrite all `Stubable` types with `Stub`s
   type Stubify<T> = T extends Stubable
     ? Stub<T>
@@ -6197,13 +6200,15 @@ declare namespace Rpc {
           ? Array<Stubify<V>>
           : T extends ReadonlyArray<infer V>
             ? ReadonlyArray<Stubify<V>>
-            : T extends {
-                  [key: string | number]: any;
-                }
-              ? {
-                  [K in keyof T]: Stubify<T[K]>;
-                }
-              : T;
+            : T extends BaseType
+              ? T
+              : T extends {
+                    [key: string | number]: any;
+                  }
+                ? {
+                    [K in keyof T]: Stubify<T[K]>;
+                  }
+                : T;
   // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
   // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
   // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
@@ -6218,13 +6223,15 @@ declare namespace Rpc {
             ? Array<Unstubify<V>>
             : T extends ReadonlyArray<infer V>
               ? ReadonlyArray<Unstubify<V>>
-              : T extends {
-                    [key: string | number]: unknown;
-                  }
-                ? {
-                    [K in keyof T]: Unstubify<T[K]>;
-                  }
-                : T;
+              : T extends BaseType
+                ? T
+                : T extends {
+                      [key: string | number]: unknown;
+                    }
+                  ? {
+                      [K in keyof T]: Unstubify<T[K]>;
+                    }
+                  : T;
   type UnstubifyAll<A extends any[]> = {
     [I in keyof A]: Unstubify<A[I]>;
   };

package/2021-11-03/index.ts

@@ -1258,7 +1258,7 @@ export declare class DigestStream extends WritableStream<
   ArrayBuffer | ArrayBufferView
 > {
   constructor(algorithm: string | SubtleCryptoHashAlgorithm);
-  readonly digest: Promise<ArrayBuffer | ArrayBufferView>;
+  readonly digest: Promise<ArrayBuffer>;
   get bytesWritten(): number | bigint;
 }
 /**
@@ -1267,7 +1267,7 @@ export declare class DigestStream extends WritableStream<
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder)
  */
 export declare class TextDecoder {
-  constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  constructor(label?: string, options?: TextDecoderConstructorOptions);
   /**
    * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
    *
@@ -3084,7 +3084,7 @@ export interface GPUCommandEncoder {
     destinationOffset: number | bigint,
     size: number | bigint,
   ): void;
-  finish(param0?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+  finish(param1?: GPUCommandBufferDescriptor): GPUCommandBuffer;
   copyTextureToBuffer(
     source: GPUImageCopyTexture,
     destination: GPUImageCopyBuffer,
@@ -6130,19 +6130,7 @@ export declare namespace Rpc {
   //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
   type Serializable<T> =
     // Structured cloneables
-    | void
-    | undefined
-    | null
-    | boolean
-    | number
-    | bigint
-    | string
-    | TypedArray
-    | ArrayBuffer
-    | DataView
-    | Date
-    | Error
-    | RegExp
+    | BaseType
     // Structured cloneable composites
     | Map<
         T extends Map<infer U, unknown> ? Serializable<U> : never,
@@ -6154,11 +6142,6 @@ export declare namespace Rpc {
         [K in keyof T]: K extends number | string ? Serializable<T[K]> : never;
       }
     // Special types
-    | ReadableStream<Uint8Array>
-    | WritableStream<Uint8Array>
-    | Request
-    | Response
-    | Headers
     | Stub<Stubable>
     // Serialized as stubs, see `Stubify`
     | Stubable;
@@ -6169,6 +6152,26 @@ export declare namespace Rpc {
     dup(): this;
   }
   export type Stub<T extends Stubable> = Provider<T> & StubBase<T>;
+  // This represents all the types that can be sent as-is over an RPC boundary
+  type BaseType =
+    | void
+    | undefined
+    | null
+    | boolean
+    | number
+    | bigint
+    | string
+    | TypedArray
+    | ArrayBuffer
+    | DataView
+    | Date
+    | Error
+    | RegExp
+    | ReadableStream<Uint8Array>
+    | WritableStream<Uint8Array>
+    | Request
+    | Response
+    | Headers;
   // Recursively rewrite all `Stubable` types with `Stub`s
   type Stubify<T> = T extends Stubable
     ? Stub<T>
@@ -6180,13 +6183,15 @@ export declare namespace Rpc {
           ? Array<Stubify<V>>
           : T extends ReadonlyArray<infer V>
             ? ReadonlyArray<Stubify<V>>
-            : T extends {
-                  [key: string | number]: any;
-                }
-              ? {
-                  [K in keyof T]: Stubify<T[K]>;
-                }
-              : T;
+            : T extends BaseType
+              ? T
+              : T extends {
+                    [key: string | number]: any;
+                  }
+                ? {
+                    [K in keyof T]: Stubify<T[K]>;
+                  }
+                : T;
   // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
   // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
   // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
@@ -6201,13 +6206,15 @@ export declare namespace Rpc {
             ? Array<Unstubify<V>>
             : T extends ReadonlyArray<infer V>
               ? ReadonlyArray<Unstubify<V>>
-              : T extends {
-                    [key: string | number]: unknown;
-                  }
-                ? {
-                    [K in keyof T]: Unstubify<T[K]>;
-                  }
-                : T;
+              : T extends BaseType
+                ? T
+                : T extends {
+                      [key: string | number]: unknown;
+                    }
+                  ? {
+                      [K in keyof T]: Unstubify<T[K]>;
+                    }
+                  : T;
   type UnstubifyAll<A extends any[]> = {
     [I in keyof A]: Unstubify<A[I]>;
   };

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

@@ -1259,7 +1259,7 @@ declare class DigestStream extends WritableStream<
   ArrayBuffer | ArrayBufferView
 > {
   constructor(algorithm: string | SubtleCryptoHashAlgorithm);
-  get digest(): Promise<ArrayBuffer | ArrayBufferView>;
+  readonly digest: Promise<ArrayBuffer>;
   get bytesWritten(): number | bigint;
 }
 /**
@@ -1268,7 +1268,7 @@ declare class DigestStream extends WritableStream<
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder)
  */
 declare class TextDecoder {
-  constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  constructor(label?: string, options?: TextDecoderConstructorOptions);
   /**
    * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
    *
@@ -3098,7 +3098,7 @@ interface GPUCommandEncoder {
     destinationOffset: number | bigint,
     size: number | bigint,
   ): void;
-  finish(param0?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+  finish(param1?: GPUCommandBufferDescriptor): GPUCommandBuffer;
   copyTextureToBuffer(
     source: GPUImageCopyTexture,
     destination: GPUImageCopyBuffer,
@@ -6173,19 +6173,7 @@ declare namespace Rpc {
   //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
   type Serializable<T> =
     // Structured cloneables
-    | void
-    | undefined
-    | null
-    | boolean
-    | number
-    | bigint
-    | string
-    | TypedArray
-    | ArrayBuffer
-    | DataView
-    | Date
-    | Error
-    | RegExp
+    | BaseType
     // Structured cloneable composites
     | Map<
         T extends Map<infer U, unknown> ? Serializable<U> : never,
@@ -6197,11 +6185,6 @@ declare namespace Rpc {
         [K in keyof T]: K extends number | string ? Serializable<T[K]> : never;
       }
     // Special types
-    | ReadableStream<Uint8Array>
-    | WritableStream<Uint8Array>
-    | Request
-    | Response
-    | Headers
     | Stub<Stubable>
     // Serialized as stubs, see `Stubify`
     | Stubable;
@@ -6212,6 +6195,26 @@ declare namespace Rpc {
     dup(): this;
   }
   export type Stub<T extends Stubable> = Provider<T> & StubBase<T>;
+  // This represents all the types that can be sent as-is over an RPC boundary
+  type BaseType =
+    | void
+    | undefined
+    | null
+    | boolean
+    | number
+    | bigint
+    | string
+    | TypedArray
+    | ArrayBuffer
+    | DataView
+    | Date
+    | Error
+    | RegExp
+    | ReadableStream<Uint8Array>
+    | WritableStream<Uint8Array>
+    | Request
+    | Response
+    | Headers;
   // Recursively rewrite all `Stubable` types with `Stub`s
   type Stubify<T> = T extends Stubable
     ? Stub<T>
@@ -6223,13 +6226,15 @@ declare namespace Rpc {
           ? Array<Stubify<V>>
           : T extends ReadonlyArray<infer V>
             ? ReadonlyArray<Stubify<V>>
-            : T extends {
-                  [key: string | number]: any;
-                }
-              ? {
-                  [K in keyof T]: Stubify<T[K]>;
-                }
-              : T;
+            : T extends BaseType
+              ? T
+              : T extends {
+                    [key: string | number]: any;
+                  }
+                ? {
+                    [K in keyof T]: Stubify<T[K]>;
+                  }
+                : T;
   // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
   // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
   // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
@@ -6244,13 +6249,15 @@ declare namespace Rpc {
             ? Array<Unstubify<V>>
             : T extends ReadonlyArray<infer V>
               ? ReadonlyArray<Unstubify<V>>
-              : T extends {
-                    [key: string | number]: unknown;
-                  }
-                ? {
-                    [K in keyof T]: Unstubify<T[K]>;
-                  }
-                : T;
+              : T extends BaseType
+                ? T
+                : T extends {
+                      [key: string | number]: unknown;
+                    }
+                  ? {
+                      [K in keyof T]: Unstubify<T[K]>;
+                    }
+                  : T;
   type UnstubifyAll<A extends any[]> = {
     [I in keyof A]: Unstubify<A[I]>;
   };

package/2022-01-31/index.ts

@@ -1264,7 +1264,7 @@ export declare class DigestStream extends WritableStream<
   ArrayBuffer | ArrayBufferView
 > {
   constructor(algorithm: string | SubtleCryptoHashAlgorithm);
-  get digest(): Promise<ArrayBuffer | ArrayBufferView>;
+  readonly digest: Promise<ArrayBuffer>;
   get bytesWritten(): number | bigint;
 }
 /**
@@ -1273,7 +1273,7 @@ export declare class DigestStream extends WritableStream<
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder)
  */
 export declare class TextDecoder {
-  constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  constructor(label?: string, options?: TextDecoderConstructorOptions);
   /**
    * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
    *
@@ -3110,7 +3110,7 @@ export interface GPUCommandEncoder {
     destinationOffset: number | bigint,
     size: number | bigint,
   ): void;
-  finish(param0?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+  finish(param1?: GPUCommandBufferDescriptor): GPUCommandBuffer;
   copyTextureToBuffer(
     source: GPUImageCopyTexture,
     destination: GPUImageCopyBuffer,
@@ -6156,19 +6156,7 @@ export declare namespace Rpc {
   //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
   type Serializable<T> =
     // Structured cloneables
-    | void
-    | undefined
-    | null
-    | boolean
-    | number
-    | bigint
-    | string
-    | TypedArray
-    | ArrayBuffer
-    | DataView
-    | Date
-    | Error
-    | RegExp
+    | BaseType
     // Structured cloneable composites
     | Map<
         T extends Map<infer U, unknown> ? Serializable<U> : never,
@@ -6180,11 +6168,6 @@ export declare namespace Rpc {
         [K in keyof T]: K extends number | string ? Serializable<T[K]> : never;
       }
     // Special types
-    | ReadableStream<Uint8Array>
-    | WritableStream<Uint8Array>
-    | Request
-    | Response
-    | Headers
     | Stub<Stubable>
     // Serialized as stubs, see `Stubify`
     | Stubable;
@@ -6195,6 +6178,26 @@ export declare namespace Rpc {
     dup(): this;
   }
   export type Stub<T extends Stubable> = Provider<T> & StubBase<T>;
+  // This represents all the types that can be sent as-is over an RPC boundary
+  type BaseType =
+    | void
+    | undefined
+    | null
+    | boolean
+    | number
+    | bigint
+    | string
+    | TypedArray
+    | ArrayBuffer
+    | DataView
+    | Date
+    | Error
+    | RegExp
+    | ReadableStream<Uint8Array>
+    | WritableStream<Uint8Array>
+    | Request
+    | Response
+    | Headers;
   // Recursively rewrite all `Stubable` types with `Stub`s
   type Stubify<T> = T extends Stubable
     ? Stub<T>
@@ -6206,13 +6209,15 @@ export declare namespace Rpc {
           ? Array<Stubify<V>>
           : T extends ReadonlyArray<infer V>
             ? ReadonlyArray<Stubify<V>>
-            : T extends {
-                  [key: string | number]: any;
-                }
-              ? {
-                  [K in keyof T]: Stubify<T[K]>;
-                }
-              : T;
+            : T extends BaseType
+              ? T
+              : T extends {
+                    [key: string | number]: any;
+                  }
+                ? {
+                    [K in keyof T]: Stubify<T[K]>;
+                  }
+                : T;
   // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
   // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
   // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
@@ -6227,13 +6232,15 @@ export declare namespace Rpc {
             ? Array<Unstubify<V>>
             : T extends ReadonlyArray<infer V>
               ? ReadonlyArray<Unstubify<V>>
-              : T extends {
-                    [key: string | number]: unknown;
-                  }
-                ? {
-                    [K in keyof T]: Unstubify<T[K]>;
-                  }
-                : T;
+              : T extends BaseType
+                ? T
+                : T extends {
+                      [key: string | number]: unknown;
+                    }
+                  ? {
+                      [K in keyof T]: Unstubify<T[K]>;
+                    }
+                  : T;
   type UnstubifyAll<A extends any[]> = {
     [I in keyof A]: Unstubify<A[I]>;
   };

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

@@ -1277,7 +1277,7 @@ declare class DigestStream extends WritableStream<
   ArrayBuffer | ArrayBufferView
 > {
   constructor(algorithm: string | SubtleCryptoHashAlgorithm);
-  get digest(): Promise<ArrayBuffer | ArrayBufferView>;
+  readonly digest: Promise<ArrayBuffer>;
   get bytesWritten(): number | bigint;
 }
 /**
@@ -1286,7 +1286,7 @@ declare class DigestStream extends WritableStream<
  * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder)
  */
 declare class TextDecoder {
-  constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  constructor(label?: string, options?: TextDecoderConstructorOptions);
   /**
    * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
    *
@@ -3119,7 +3119,7 @@ interface GPUCommandEncoder {
     destinationOffset: number | bigint,
     size: number | bigint,
   ): void;
-  finish(param0?: GPUCommandBufferDescriptor): GPUCommandBuffer;
+  finish(param1?: GPUCommandBufferDescriptor): GPUCommandBuffer;
   copyTextureToBuffer(
     source: GPUImageCopyTexture,
     destination: GPUImageCopyBuffer,
@@ -6198,19 +6198,7 @@ declare namespace Rpc {
   //   serializable check as well. Otherwise, only types defined with the "type" keyword would pass.
   type Serializable<T> =
     // Structured cloneables
-    | void
-    | undefined
-    | null
-    | boolean
-    | number
-    | bigint
-    | string
-    | TypedArray
-    | ArrayBuffer
-    | DataView
-    | Date
-    | Error
-    | RegExp
+    | BaseType
     // Structured cloneable composites
     | Map<
         T extends Map<infer U, unknown> ? Serializable<U> : never,
@@ -6222,11 +6210,6 @@ declare namespace Rpc {
         [K in keyof T]: K extends number | string ? Serializable<T[K]> : never;
       }
     // Special types
-    | ReadableStream<Uint8Array>
-    | WritableStream<Uint8Array>
-    | Request
-    | Response
-    | Headers
     | Stub<Stubable>
     // Serialized as stubs, see `Stubify`
     | Stubable;
@@ -6237,6 +6220,26 @@ declare namespace Rpc {
     dup(): this;
   }
   export type Stub<T extends Stubable> = Provider<T> & StubBase<T>;
+  // This represents all the types that can be sent as-is over an RPC boundary
+  type BaseType =
+    | void
+    | undefined
+    | null
+    | boolean
+    | number
+    | bigint
+    | string
+    | TypedArray
+    | ArrayBuffer
+    | DataView
+    | Date
+    | Error
+    | RegExp
+    | ReadableStream<Uint8Array>
+    | WritableStream<Uint8Array>
+    | Request
+    | Response
+    | Headers;
   // Recursively rewrite all `Stubable` types with `Stub`s
   type Stubify<T> = T extends Stubable
     ? Stub<T>
@@ -6248,13 +6251,15 @@ declare namespace Rpc {
           ? Array<Stubify<V>>
           : T extends ReadonlyArray<infer V>
             ? ReadonlyArray<Stubify<V>>
-            : T extends {
-                  [key: string | number]: any;
-                }
-              ? {
-                  [K in keyof T]: Stubify<T[K]>;
-                }
-              : T;
+            : T extends BaseType
+              ? T
+              : T extends {
+                    [key: string | number]: any;
+                  }
+                ? {
+                    [K in keyof T]: Stubify<T[K]>;
+                  }
+                : T;
   // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
   // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
   // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
@@ -6269,13 +6274,15 @@ declare namespace Rpc {
             ? Array<Unstubify<V>>
             : T extends ReadonlyArray<infer V>
               ? ReadonlyArray<Unstubify<V>>
-              : T extends {
-                    [key: string | number]: unknown;
-                  }
-                ? {
-                    [K in keyof T]: Unstubify<T[K]>;
-                  }
-                : T;
+              : T extends BaseType
+                ? T
+                : T extends {
+                      [key: string | number]: unknown;
+                    }
+                  ? {
+                      [K in keyof T]: Unstubify<T[K]>;
+                    }
+                  : T;
   type UnstubifyAll<A extends any[]> = {
     [I in keyof A]: Unstubify<A[I]>;
   };