@cloudflare/workers-types 3.3.0 → 3.5.0

package/index.d.ts

@@ -62,7 +62,14 @@ interface BasicImageTransformations {
    * preserve as much as possible around a point at 20% of the height of the
    * source image.
    */
-  gravity?: "left" | "right" | "top" | "bottom" | "center" | "auto" | BasicImageTransformationsGravityCoordinates;
+  gravity?:
+    | "left"
+    | "right"
+    | "top"
+    | "bottom"
+    | "center"
+    | "auto"
+    | BasicImageTransformationsGravityCoordinates;
   /**
    * Background color to add underneath the image. Applies only to images with
    * transparency (such as PNG). Accepts any CSS color (#RRGGBB, rgba(…),
@@ -107,7 +114,13 @@ declare abstract class Body {
   blob(): Promise<Blob>;
 }
 
-declare type BodyInit = ReadableStream | string | ArrayBuffer | Blob | URLSearchParams | FormData;
+declare type BodyInit =
+  | ReadableStream
+  | string
+  | ArrayBuffer
+  | Blob
+  | URLSearchParams
+  | FormData;
 
 /**
  * Back compat for code migrating to older definitions.
@@ -115,9 +128,21 @@ declare type BodyInit = ReadableStream | string | ArrayBuffer | Blob | URLSearch
  */
 declare type BodyInitializer = BodyInit;
 
+declare class ByteLengthQueuingStrategy {
+  constructor(init: QueuingStrategyInit);
+  readonly highWaterMark: number;
+  size(arg1?: any): number | undefined;
+}
+
 declare abstract class Cache {
-  delete(request: Request | string, options?: CacheQueryOptions): Promise<boolean>;
-  match(request: Request | string, options?: CacheQueryOptions): Promise<Response | undefined>;
+  delete(
+    request: Request | string,
+    options?: CacheQueryOptions
+  ): Promise<boolean>;
+  match(
+    request: Request | string,
+    options?: CacheQueryOptions
+  ): Promise<Response | undefined>;
   put(request: Request | string, response: Response): Promise<void>;
 }
 
@@ -168,6 +193,10 @@ interface Comment {
   remove(): Comment;
 }
 
+declare class CompressionStream extends TransformStream {
+  constructor(format: string);
+}
+
 interface Console {
   debug(...data: any[]): void;
   error(...data: any[]): void;
@@ -182,9 +211,25 @@ interface ContentOptions {
   html?: boolean;
 }
 
+declare class CountQueuingStrategy {
+  constructor(init: QueuingStrategyInit);
+  readonly highWaterMark: number;
+  size(arg1?: any): number | undefined;
+}
+
 declare abstract class Crypto {
   readonly subtle: SubtleCrypto;
-  getRandomValues<T extends Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(buffer: T): T;
+  getRandomValues<
+    T extends
+      | Int8Array
+      | Uint8Array
+      | Int16Array
+      | Uint16Array
+      | Int32Array
+      | Uint32Array
+      | BigInt64Array
+      | BigUint64Array
+  >(buffer: T): T;
   randomUUID(): string;
 }
 
@@ -200,7 +245,14 @@ interface CryptoKeyAesKeyAlgorithm {
   length: number;
 }
 
-declare type CryptoKeyAlgorithmVariant = CryptoKeyKeyAlgorithm | CryptoKeyAesKeyAlgorithm | CryptoKeyHmacKeyAlgorithm | CryptoKeyRsaKeyAlgorithm | CryptoKeyEllipticKeyAlgorithm | CryptoKeyVoprfKeyAlgorithm | CryptoKeyOprfKeyAlgorithm;
+declare type CryptoKeyAlgorithmVariant =
+  | CryptoKeyKeyAlgorithm
+  | CryptoKeyAesKeyAlgorithm
+  | CryptoKeyHmacKeyAlgorithm
+  | CryptoKeyRsaKeyAlgorithm
+  | CryptoKeyEllipticKeyAlgorithm
+  | CryptoKeyVoprfKeyAlgorithm
+  | CryptoKeyOprfKeyAlgorithm;
 
 interface CryptoKeyEllipticKeyAlgorithm {
   name: string;
@@ -270,6 +322,10 @@ declare class DOMException extends Error {
   static readonly DATA_CLONE_ERR: number;
 }
 
+declare class DecompressionStream extends TransformStream {
+  constructor(format: string);
+}
+
 declare class DigestStream extends WritableStream {
   constructor(algorithm: string | SubtleCryptoHashAlgorithm);
   readonly digest: Promise<ArrayBuffer>;
@@ -289,6 +345,10 @@ interface DurableObject {
   fetch(request: Request): Promise<Response>;
 }
 
+interface DurableObjectGetAlarmOptions {
+  allowConcurrency?: boolean;
+}
+
 interface DurableObjectGetOptions {
   allowConcurrency?: boolean;
   noCache?: boolean;
@@ -311,7 +371,9 @@ interface DurableObjectListOptions {
 }
 
 interface DurableObjectNamespace {
-  newUniqueId(options?: DurableObjectNamespaceNewUniqueIdOptions): DurableObjectId;
+  newUniqueId(
+    options?: DurableObjectNamespaceNewUniqueIdOptions
+  ): DurableObjectId;
   idFromName(name: string): DurableObjectId;
   idFromString(id: string): DurableObjectId;
   get(id: DurableObjectId): DurableObjectStub;
@@ -327,6 +389,11 @@ interface DurableObjectPutOptions {
   noCache?: boolean;
 }
 
+interface DurableObjectSetAlarmOptions {
+  allowConcurrency?: boolean;
+  allowUnconfirmed?: boolean;
+}
+
 interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId | string;
@@ -335,32 +402,52 @@ interface DurableObjectState {
 }
 
 interface DurableObjectStorage {
-  get<T = unknown>(key: string, options?: DurableObjectGetOptions): Promise<T | undefined>;
-  get<T = unknown>(keys: string[], options?: DurableObjectGetOptions): Promise<Map<string, T>>;
-  list<T = unknown>(options?: DurableObjectListOptions): Promise<Map<string, T>>;
-  put<T>(key: string, value: T, options?: DurableObjectPutOptions): Promise<void>;
-  put<T>(entries: Record<string, T>, options?: DurableObjectPutOptions): Promise<void>;
+  get<T = unknown>(
+    key: string,
+    options?: DurableObjectGetOptions
+  ): Promise<T | undefined>;
+  get<T = unknown>(
+    keys: string[],
+    options?: DurableObjectGetOptions
+  ): Promise<Map<string, T>>;
+  list<T = unknown>(
+    options?: DurableObjectListOptions
+  ): Promise<Map<string, T>>;
+  put<T>(
+    key: string,
+    value: T,
+    options?: DurableObjectPutOptions
+  ): Promise<void>;
+  put<T>(
+    entries: Record<string, T>,
+    options?: DurableObjectPutOptions
+  ): Promise<void>;
   delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
   delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
   deleteAll(options?: DurableObjectPutOptions): Promise<void>;
-  transaction<T>(closure: (txn: DurableObjectTransaction) => Promise<T>): Promise<T>;
+  transaction<T>(
+    closure: (txn: DurableObjectTransaction) => Promise<T>
+  ): Promise<T>;
+  getAlarm(options?: DurableObjectGetAlarmOptions): Promise<Date | null>;
+  setAlarm(arg2: Date, options?: DurableObjectSetAlarmOptions): Promise<void>;
 }
 
 /**
- * 
- * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ *
+ * @deprecated Don't use. Introduced incidentally in workers-types 3.x. Scheduled for removal.
  */
 declare type DurableObjectStorageOperationsGetOptions = DurableObjectGetOptions;
 
 /**
- * 
- * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ *
+ * @deprecated Don't use. Introduced incidentally in workers-types 3.x. Scheduled for removal.
  */
-declare type DurableObjectStorageOperationsListOptions = DurableObjectListOptions;
+declare type DurableObjectStorageOperationsListOptions =
+  DurableObjectListOptions;
 
 /**
- * 
- * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ *
+ * @deprecated Don't use. Introduced incidentally in workers-types 3.x. Scheduled for removal.
  */
 declare type DurableObjectStorageOperationsPutOptions = DurableObjectPutOptions;
 
@@ -371,13 +458,27 @@ interface DurableObjectStub extends Fetcher {
 
 interface DurableObjectTransaction {
   get<T = unknown>(key: string, options?: DurableObjectGetOptions): Promise<T>;
-  get<T = unknown>(keys: string[], options?: DurableObjectGetOptions): Promise<Map<string, T>>;
-  list<T = unknown>(options?: DurableObjectListOptions): Promise<Map<string, T>>;
-  put<T>(key: string, value: T, options?: DurableObjectPutOptions): Promise<void>;
-  put<T>(entries: Record<string, T>, options?: DurableObjectPutOptions): Promise<void>;
+  get<T = unknown>(
+    keys: string[],
+    options?: DurableObjectGetOptions
+  ): Promise<Map<string, T>>;
+  list<T = unknown>(
+    options?: DurableObjectListOptions
+  ): Promise<Map<string, T>>;
+  put<T>(
+    key: string,
+    value: T,
+    options?: DurableObjectPutOptions
+  ): Promise<void>;
+  put<T>(
+    entries: Record<string, T>,
+    options?: DurableObjectPutOptions
+  ): Promise<void>;
   delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
   delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
   rollback(): void;
+  getAlarm(options?: DurableObjectGetAlarmOptions): Promise<Date | null>;
+  setAlarm(arg2: Date, options?: DurableObjectSetAlarmOptions): Promise<void>;
 }
 
 interface Element {
@@ -397,6 +498,22 @@ interface Element {
   remove(): Element;
   removeAndKeepContent(): Element;
   setInnerContent(content: Content, options?: ContentOptions): Element;
+  onEndTag(handler: (tag: EndTag) => void | Promise<void>): void;
+}
+
+interface EndTag {
+  name: string;
+  before(content: Content, options?: ContentOptions): EndTag;
+  after(content: Content, options?: ContentOptions): EndTag;
+  remove(): EndTag;
+}
+
+interface ErrorEvent extends Event {
+  readonly filename: string;
+  readonly message: string;
+  readonly lineno: number;
+  readonly colno: number;
+  readonly error: any;
 }
 
 declare class Event {
@@ -429,18 +546,32 @@ interface EventInit {
   composed?: boolean;
 }
 
-declare type EventListener<EventType extends Event = Event> = (event: EventType) => void;
+declare type EventListener<EventType extends Event = Event> = (
+  event: EventType
+) => void;
 
 interface EventListenerObject<EventType extends Event = Event> {
   handleEvent(event: EventType): void;
 }
 
-declare type EventListenerOrEventListenerObject<EventType extends Event = Event> = EventListener<EventType> | EventListenerObject<EventType>;
+declare type EventListenerOrEventListenerObject<
+  EventType extends Event = Event
+> = EventListener<EventType> | EventListenerObject<EventType>;
 
-declare class EventTarget<EventMap extends Record<string, Event> = Record<string, Event>> {
+declare class EventTarget<
+  EventMap extends Record<string, Event> = Record<string, Event>
+> {
   constructor();
-  addEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetAddEventListenerOptions | boolean): void;
-  removeEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
+  addEventListener<Type extends keyof EventMap>(
+    type: Type,
+    handler: EventListenerOrEventListenerObject<EventMap[Type]>,
+    options?: EventTargetAddEventListenerOptions | boolean
+  ): void;
+  removeEventListener<Type extends keyof EventMap>(
+    type: Type,
+    handler: EventListenerOrEventListenerObject<EventMap[Type]>,
+    options?: EventTargetEventListenerOptions | boolean
+  ): void;
   dispatchEvent(event: EventMap[keyof EventMap]): boolean;
 }
 
@@ -465,9 +596,17 @@ interface ExportedHandler<Env = unknown> {
   scheduled?: ExportedHandlerScheduledHandler<Env>;
 }
 
-declare type ExportedHandlerFetchHandler<Env = unknown> = (request: Request, env: Env, ctx: ExecutionContext) => Response | Promise<Response>;
+declare type ExportedHandlerFetchHandler<Env = unknown> = (
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext
+) => Response | Promise<Response>;
 
-declare type ExportedHandlerScheduledHandler<Env = unknown> = (controller: ScheduledController, env: Env, ctx: ExecutionContext) => void | Promise<void>;
+declare type ExportedHandlerScheduledHandler<Env = unknown> = (
+  controller: ScheduledController,
+  env: Env,
+  ctx: ExecutionContext
+) => void | Promise<void>;
 
 declare abstract class FetchEvent extends Event {
   readonly request: Request;
@@ -477,7 +616,10 @@ declare abstract class FetchEvent extends Event {
 }
 
 declare abstract class Fetcher {
-  fetch(requestOrUrl: Request | string, requestInit?: RequestInit | Request): Promise<Response>;
+  fetch(
+    requestOrUrl: Request | string,
+    requestInit?: RequestInit | Request
+  ): Promise<Response>;
 }
 
 declare class File extends Blob {
@@ -492,7 +634,7 @@ interface FileOptions {
 }
 
 declare class FixedLengthStream extends TransformStream {
-  constructor(expectedLength: number);
+  constructor(expectedLength: number | bigint);
 }
 
 declare class FormData {
@@ -505,16 +647,27 @@ declare class FormData {
   has(name: string): boolean;
   set(name: string, value: string): void;
   set(name: string, value: Blob, filename?: string): void;
-  entries(): IterableIterator<([key: string, value: File | string])[]>;
+  entries(): IterableIterator<[key: string, value: File | string]>;
   keys(): IterableIterator<string>;
   values(): IterableIterator<File | string>;
-  forEach<This = unknown>(callback: (this: This, key: string, value: File | string, parent: FormData) => void, thisArg?: This): void;
-  [Symbol.iterator](): IterableIterator<([key: string, value: File | string])[]>;
+  forEach<This = unknown>(
+    callback: (
+      this: This,
+      key: string,
+      value: File | string,
+      parent: FormData
+    ) => void,
+    thisArg?: This
+  ): void;
+  [Symbol.iterator](): IterableIterator<[key: string, value: File | string]>;
 }
 
 declare class HTMLRewriter {
   constructor();
-  on(selector: string, handlers: HTMLRewriterElementContentHandlers): HTMLRewriter;
+  on(
+    selector: string,
+    handlers: HTMLRewriterElementContentHandlers
+  ): HTMLRewriter;
   onDocument(handlers: HTMLRewriterDocumentContentHandlers): HTMLRewriter;
   transform(response: Response): Response;
 }
@@ -540,14 +693,20 @@ declare class Headers {
   set(name: string, value: string): void;
   append(name: string, value: string): void;
   delete(name: string): void;
-  forEach<This = unknown>(callback: (this: This, key: string, value: string, parent: Headers) => void, thisArg?: This): void;
+  forEach<This = unknown>(
+    callback: (this: This, key: string, value: string, parent: Headers) => void,
+    thisArg?: This
+  ): void;
   entries(): IterableIterator<[key: string, value: string]>;
   keys(): IterableIterator<string>;
   values(): IterableIterator<string>;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
 }
 
-declare type HeadersInit = Headers | Record<string, string> | ([key: string, value: string])[];
+declare type HeadersInit =
+  | Headers
+  | Record<string, string>
+  | [key: string, value: string][];
 
 /**
  * Back compat for code migrating to older definitions.
@@ -555,11 +714,15 @@ declare type HeadersInit = Headers | Record<string, string> | ([key: string, val
  */
 declare type HeadersInitializer = HeadersInit;
 
+declare class IdentityTransformStream extends TransformStream {
+  constructor();
+}
+
 /**
  * In addition to the properties on the standard Request object,
  * the cf object contains extra information about the request provided
  * by Cloudflare's edge.
- * 
+ *
  * Note: Currently, settings in the cf object cannot be accessed in the
  * playground.
  */
@@ -670,35 +833,83 @@ interface JsonWebKey {
  * Workers KV is a global, low-latency, key-value data store. It supports exceptionally high read volumes with low-latency,
  * making it possible to build highly dynamic APIs and websites which respond as quickly as a cached static file would.
  */
-interface KVNamespace {
-  get(key: string, options?: Partial<KVNamespaceGetOptions<undefined>>): Promise<string | null>;
-  get(key: string, type: "text"): Promise<string | null>;
-  get<ExpectedValue = unknown>(key: string, type: "json"): Promise<ExpectedValue | null>;
-  get(key: string, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
-  get(key: string, type: "stream"): Promise<ReadableStream | null>;
-  get(key: string, options: KVNamespaceGetOptions<"text">): Promise<string | null>;
-  get<ExpectedValue = unknown>(key: string, options: KVNamespaceGetOptions<"json">): Promise<ExpectedValue | null>;
-  get(key: string, options: KVNamespaceGetOptions<"arrayBuffer">): Promise<ArrayBuffer | null>;
-  get(key: string, options: KVNamespaceGetOptions<"stream">): Promise<ReadableStream | null>;
-  list<Metadata = unknown>(options?: KVNamespaceListOptions): Promise<KVNamespaceListResult<Metadata>>;
+interface KVNamespace<K extends string = string> {
+  get(
+    key: K,
+    options?: Partial<KVNamespaceGetOptions<undefined>>
+  ): Promise<string | null>;
+  get(key: K, type: "text"): Promise<string | null>;
+  get<ExpectedValue = unknown>(
+    key: K,
+    type: "json"
+  ): Promise<ExpectedValue | null>;
+  get(key: K, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
+  get(key: K, type: "stream"): Promise<ReadableStream | null>;
+  get(key: K, options: KVNamespaceGetOptions<"text">): Promise<string | null>;
+  get<ExpectedValue = unknown>(
+    key: string,
+    options: KVNamespaceGetOptions<"json">
+  ): Promise<ExpectedValue | null>;
+  get(
+    key: K,
+    options: KVNamespaceGetOptions<"arrayBuffer">
+  ): Promise<ArrayBuffer | null>;
+  get(
+    key: K,
+    options: KVNamespaceGetOptions<"stream">
+  ): Promise<ReadableStream | null>;
+  list<Metadata = unknown>(
+    options?: KVNamespaceListOptions
+  ): Promise<KVNamespaceListResult<Metadata>>;
   /**
    * Creates a new key-value pair, or updates the value for a particular key.
    * @param key key to associate with the value. A key cannot be empty, `.` or `..`. All other keys are valid.
    * @param value value to store. The type is inferred. The maximum size of a value is 25MB.
    * @returns Returns a `Promise` that you should `await` on in order to verify a successful update.
    * @example
-   * await NAMESPACE.put(key, value)
+   * await NAMESPACE.put(key, value);
    */
-  put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: KVNamespacePutOptions): Promise<void>;
-  getWithMetadata<Metadata = unknown>(key: string, options?: Partial<KVNamespaceGetOptions<undefined>>): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
-  getWithMetadata<Metadata = unknown>(key: string, type: "text"): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
-  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(key: string, type: "json"): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
-  getWithMetadata<Metadata = unknown>(key: string, type: "arrayBuffer"): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
-  getWithMetadata<Metadata = unknown>(key: string, type: "stream"): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
-  getWithMetadata<Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"text">): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
-  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"json">): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
-  getWithMetadata<Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"arrayBuffer">): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
-  getWithMetadata<Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"stream">): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
+  put(
+    key: K,
+    value: string | ArrayBuffer | ArrayBufferView | ReadableStream,
+    options?: KVNamespacePutOptions
+  ): Promise<void>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options?: Partial<KVNamespaceGetOptions<undefined>>
+  ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    type: "text"
+  ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
+    key: K,
+    type: "json"
+  ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    type: "arrayBuffer"
+  ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    type: "stream"
+  ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"text">
+  ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"json">
+  ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"arrayBuffer">
+  ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"stream">
+  ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
   delete(name: string): Promise<void>;
 }
 
@@ -751,6 +962,10 @@ interface MessageEventInit {
  */
 declare type MessageEventInitializer = MessageEventInit;
 
+declare abstract class Navigator {
+  readonly userAgent: string;
+}
+
 /**
  * Transitionary name.
  * @deprecated Use StreamPipeOptions
@@ -766,12 +981,147 @@ declare abstract class PromiseRejectionEvent extends Event {
   readonly reason: any;
 }
 
+interface QueuingStrategyInit {
+  highWaterMark: number;
+}
+
+/**
+ * An instance of the R2 bucket binding.
+ */
+interface R2Bucket {
+  head(key: string, options?: R2HeadOptions): Promise<R2Object | null>;
+  get(key: string, options?: R2GetOptions): Promise<R2ObjectBody | null>;
+  put(
+    key: string,
+    value: ReadableStream | ArrayBuffer | ArrayBufferView | string | null,
+    options?: R2PutOptions
+  ): Promise<R2Object>;
+  delete(key: string): Promise<void>;
+  list(options?: R2ListOptions): Promise<R2Objects>;
+}
+
+/**
+ * Perform the operation conditionally based on meeting the defined criteria.
+ */
+interface R2Conditional {
+  etagMatches?: string;
+  etagDoesNotMatch?: string;
+  uploadedBefore?: Date;
+  uploadedAfter?: Date;
+}
+
+interface R2Error {
+  readonly stack: string;
+}
+
+/**
+ * Options for retrieving the object metadata nad payload.
+ */
+interface R2GetOptions {
+  onlyIf?: R2Conditional | Headers;
+  range?: R2Range;
+}
+
+/**
+ * Metadata that's automatically rendered into R2 HTTP API endpoints.
+ * ```
+ * * contentType -> content-type
+ * * contentLanguage -> content-language
+ * etc...
+ * ```
+ * This data is echoed back on GET responses based on what was originally
+ * assigned to the object (and can typically also be overriden when issuing
+ * the GET request).
+ */
+interface R2HTTPMetadata {
+  contentType?: string;
+  contentLanguage?: string;
+  contentDisposition?: string;
+  contentEncoding?: string;
+  cacheControl?: string;
+  cacheExpiry?: Date;
+}
+
+/**
+ * Options for retrieving the object metadata.
+ */
+interface R2HeadOptions {
+  onlyIf?: R2Conditional | Headers;
+}
+
+interface R2ListOptions {
+  limit?: number;
+  prefix?: string;
+  cursor?: string;
+  delimiter?: string;
+  /**
+   * If you populate this array, then items returned will include this metadata.
+   * A tradeoff is that fewer results may be returned depending on how big this
+   * data is. For now the caps are TBD but expect the total memory usage for a list
+   * operation may need to be <1MB or even <128kb depending on how many list operations
+   * you are sending into one bucket. Make sure to look at `truncated` for the result
+   * rather than having logic like
+   * ```
+   * while (listed.length < limit) {
+   *   listed = myBucket.list({ limit, include: ['customMetadata'] })
+   * }
+   * ```
+   */
+  include: ("httpMetadata" | "customMetadata")[];
+}
+
+/**
+ * The metadata for the object.
+ */
+declare abstract class R2Object {
+  readonly key: string;
+  readonly version: string;
+  readonly size: number;
+  readonly etag: string;
+  readonly httpEtag: string;
+  readonly uploaded: Date;
+  readonly httpMetadata: R2HTTPMetadata;
+  readonly customMetadata: Record<string, string>;
+  writeHttpMetadata(headers: Headers): void;
+}
+
+/**
+ * The metadata for the object and the body of the payload.
+ */
+interface R2ObjectBody extends R2Object {
+  readonly body: ReadableStream;
+  readonly bodyUsed: boolean;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  json<T>(): Promise<T>;
+  blob(): Promise<Blob>;
+}
+
+interface R2Objects {
+  objects: R2Object[];
+  truncated: boolean;
+  cursor?: string;
+  delimitedPrefixes: string[];
+}
+
+interface R2PutOptions {
+  httpMetadata?: R2HTTPMetadata | Headers;
+  customMetadata?: Record<string, string>;
+  md5?: ArrayBuffer | string;
+  sha1?: ArrayBuffer | string;
+}
+
+interface R2Range {
+  offset: number;
+  length: number;
+}
+
 interface ReadResult {
   value?: any;
   done: boolean;
 }
 
-interface ReadableByteStreamController {
+declare abstract class ReadableByteStreamController {
   readonly byobRequest: ReadableStreamBYOBRequest | null;
   readonly desiredSize: number | null;
   close(): void;
@@ -785,28 +1135,40 @@ declare class ReadableStream {
   cancel(reason?: any): Promise<void>;
   getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
   getReader(): ReadableStreamDefaultReader;
-  pipeThrough(transform: ReadableStreamTransform, options?: PipeToOptions): ReadableStream;
+  pipeThrough(
+    transform: ReadableStreamTransform,
+    options?: PipeToOptions
+  ): ReadableStream;
   pipeTo(destination: WritableStream, options?: PipeToOptions): Promise<void>;
   tee(): [ReadableStream, ReadableStream];
+  values(options?: ReadableStreamValuesOptions): AsyncIterableIterator<any>;
+  [Symbol.asyncIterator](
+    options?: ReadableStreamValuesOptions
+  ): AsyncIterableIterator<any>;
 }
 
 declare class ReadableStreamBYOBReader {
   constructor(stream: ReadableStream);
   readonly closed: Promise<void>;
   cancel(reason?: any): Promise<void>;
-  read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
+  read<T extends ArrayBufferView>(
+    view: T
+  ): Promise<ReadableStreamReadResult<T>>;
   releaseLock(): void;
-  readAtLeast(minBytes: number, view: Uint8Array): Promise<ReadableStreamReadResult<Uint8Array>>;
+  readAtLeast(
+    minBytes: number,
+    view: Uint8Array
+  ): Promise<ReadableStreamReadResult<Uint8Array>>;
 }
 
-interface ReadableStreamBYOBRequest {
+declare abstract class ReadableStreamBYOBRequest {
   readonly view: Uint8Array | null;
   respond(bytesWritten: number): void;
   respondWithNewView(view: ArrayBufferView): void;
   readonly atLeast: number | null;
 }
 
-interface ReadableStreamDefaultController {
+declare abstract class ReadableStreamDefaultController {
   readonly desiredSize: number | null;
   close(): void;
   enqueue(chunk?: any): void;
@@ -831,7 +1193,9 @@ interface ReadableStreamGetReaderOptions {
  */
 declare type ReadableStreamPipeToOptions = PipeToOptions;
 
-declare type ReadableStreamReadResult<T = any> = { done: true; value: undefined; } | { done: false; value: T; };
+declare type ReadableStreamReadResult<T = any> =
+  | { done: true; value: undefined }
+  | { done: false; value: T };
 
 /**
  * Back-compat alias.
@@ -843,13 +1207,18 @@ declare type ReadableStreamReadableStreamBYOBReader = ReadableStreamBYOBReader;
  * Back-compat alias.
  * @deprecated Use ReadableStreamDefaultReader
  */
-declare type ReadableStreamReadableStreamDefaultReader = ReadableStreamDefaultReader;
+declare type ReadableStreamReadableStreamDefaultReader =
+  ReadableStreamDefaultReader;
 
 interface ReadableStreamTransform {
   writable: WritableStream;
   readable: ReadableStream;
 }
 
+interface ReadableStreamValuesOptions {
+  preventCancel?: boolean;
+}
+
 declare class Request extends Body {
   constructor(input: Request | string, init?: RequestInit | Request);
   clone(): Request;
@@ -871,10 +1240,10 @@ interface RequestInit {
   /**
    * cf is a union of these two types because there are multiple
    * scenarios in which it might be one or the other.
-   * 
+   *
    * IncomingRequestCfProperties is required to allow
    *   new Request(someUrl, event.request)
-   * 
+   *
    * RequestInitCfProperties is required to allow
    *   new Request(event.request, {cf: { ... } })
    *   fetch(someUrl, {cf: { ... } })
@@ -888,7 +1257,7 @@ interface RequestInit {
  * that you pass as an argument to the Request constructor, you can
  * set certain properties of a `cf` object to control how Cloudflare
  * features are applied to that new Request.
- * 
+ *
  * Note: Currently, these properties cannot be tested in the
  * playground.
  */
@@ -899,7 +1268,7 @@ interface RequestInitCfProperties {
    * "the same" for caching purposes. If a request has the same cache key
    * as some previous request, then we can serve the same cached response for
    * both. (e.g. 'some-key')
-   * 
+   *
    * Only available for Enterprise customers.
    */
   cacheKey?: string;
@@ -917,12 +1286,12 @@ interface RequestInitCfProperties {
   image?: RequestInitCfPropertiesImage;
   minify?: RequestInitCfPropertiesImageMinify;
   mirage?: boolean;
-  polish?: 'lossy' | 'lossless' | 'off';
+  polish?: "lossy" | "lossless" | "off";
   /**
    * Redirects the request to an alternate origin server. You can use this,
    * for example, to implement load balancing across several origins.
    * (e.g.us-east.example.com)
-   * 
+   *
    * Note - For security reasons, the hostname set in resolveOverride must
    * be proxied on the same Cloudflare zone of the incoming request.
    * Otherwise, the setting is ignored. CNAME hosts are allowed, so to
@@ -946,7 +1315,7 @@ interface RequestInitCfPropertiesImage extends BasicImageTransformations {
    * or cutting out a specific fragment of an image. Trimming is performed
    * before resizing or rotation. Takes dpr into account.
    */
-  trim?: { left?: number; top?: number; right?: number; bottom?: number; };
+  trim?: { left?: number; top?: number; right?: number; bottom?: number };
   /**
    * Quality setting from 1-100 (useful values are in 60-90 range). Lower values
    * make images look worse, but load faster. The default is 85. It applies only
@@ -1031,9 +1400,9 @@ interface RequestInitCfPropertiesImageDraw extends BasicImageTransformations {
    * positions left side of the overlay 10 pixels from the left edge of the
    * image it's drawn over. bottom: 0 aligns bottom of the overlay with bottom
    * of the background image.
-   * 
+   *
    * Setting both left & right, or both top & bottom is an error.
-   * 
+   *
    * If no position is specified, the image will be centered.
    */
   top?: number;
@@ -1113,17 +1482,32 @@ interface SchedulerWaitOptions {
 interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   btoa(data: string): string;
   atob(data: string): string;
-  setTimeout<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+  setTimeout<Args extends any[]>(
+    callback: (...args: Args) => void,
+    msDelay?: number,
+    ...args: Args
+  ): number;
   clearTimeout(timeoutId: number | null): void;
-  setInterval<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+  setInterval<Args extends any[]>(
+    callback: (...args: Args) => void,
+    msDelay?: number,
+    ...args: Args
+  ): number;
   clearInterval(timeoutId: number | null): void;
   queueMicrotask(task: Function): void;
-  structuredClone(value: any, options?: ServiceWorkerGlobalScopeStructuredCloneOptions): any;
-  fetch(request: Request | string, requestInitr?: RequestInit | Request): Promise<Response>;
+  structuredClone(
+    value: any,
+    options?: ServiceWorkerGlobalScopeStructuredCloneOptions
+  ): any;
+  fetch(
+    request: Request | string,
+    requestInitr?: RequestInit | Request
+  ): Promise<Response>;
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
   caches: CacheStorage;
   scheduler: Scheduler;
+  navigator: Navigator;
   readonly console: Console;
   origin: void;
 }
@@ -1140,18 +1524,71 @@ interface StreamQueuingStrategy {
 }
 
 declare abstract class SubtleCrypto {
-  encrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, plainText: ArrayBuffer): Promise<ArrayBuffer>;
-  decrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, cipherText: ArrayBuffer): Promise<ArrayBuffer>;
-  sign(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-  verify(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean>;
-  digest(algorithm: string | SubtleCryptoHashAlgorithm, data: ArrayBuffer): Promise<ArrayBuffer>;
-  generateKey(algorithm: string | SubtleCryptoGenerateKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey | CryptoKeyPair>;
-  deriveKey(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, derivedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
-  deriveBits(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, length: number | null): Promise<ArrayBuffer>;
-  importKey(format: string, keyData: ArrayBuffer | JsonWebKey, algorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  encrypt(
+    algorithm: string | SubtleCryptoEncryptAlgorithm,
+    key: CryptoKey,
+    plainText: ArrayBuffer | ArrayBufferView
+  ): Promise<ArrayBuffer>;
+  decrypt(
+    algorithm: string | SubtleCryptoEncryptAlgorithm,
+    key: CryptoKey,
+    cipherText: ArrayBuffer | ArrayBufferView
+  ): Promise<ArrayBuffer>;
+  sign(
+    algorithm: string | SubtleCryptoSignAlgorithm,
+    key: CryptoKey,
+    data: ArrayBuffer | ArrayBufferView
+  ): Promise<ArrayBuffer>;
+  verify(
+    algorithm: string | SubtleCryptoSignAlgorithm,
+    key: CryptoKey,
+    signature: ArrayBuffer | ArrayBufferView,
+    data: ArrayBuffer | ArrayBufferView
+  ): Promise<boolean>;
+  digest(
+    algorithm: string | SubtleCryptoHashAlgorithm,
+    data: ArrayBuffer | ArrayBufferView
+  ): Promise<ArrayBuffer>;
+  generateKey(
+    algorithm: string | SubtleCryptoGenerateKeyAlgorithm,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey | CryptoKeyPair>;
+  deriveKey(
+    algorithm: string | SubtleCryptoDeriveKeyAlgorithm,
+    baseKey: CryptoKey,
+    derivedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey>;
+  deriveBits(
+    algorithm: string | SubtleCryptoDeriveKeyAlgorithm,
+    baseKey: CryptoKey,
+    length: number | null
+  ): Promise<ArrayBuffer>;
+  importKey(
+    format: string,
+    keyData: ArrayBuffer | JsonWebKey,
+    algorithm: string | SubtleCryptoImportKeyAlgorithm,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey>;
   exportKey(format: string, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
-  wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: string | SubtleCryptoEncryptAlgorithm): Promise<ArrayBuffer>;
-  unwrapKey(format: string, wrappedKey: ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm, unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  wrapKey(
+    format: string,
+    key: CryptoKey,
+    wrappingKey: CryptoKey,
+    wrapAlgorithm: string | SubtleCryptoEncryptAlgorithm
+  ): Promise<ArrayBuffer>;
+  unwrapKey(
+    format: string,
+    wrappedKey: ArrayBuffer | ArrayBufferView,
+    unwrappingKey: CryptoKey,
+    unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm,
+    unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey>;
 }
 
 interface SubtleCryptoDeriveKeyAlgorithm {
@@ -1195,13 +1632,13 @@ interface SubtleCryptoImportKeyAlgorithm {
 }
 
 /**
- * 
+ *
  * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
  */
 declare type SubtleCryptoJsonWebKey = JsonWebKey;
 
 /**
- * 
+ *
  * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
  */
 declare type SubtleCryptoJsonWebKeyRsaOtherPrimesInfo = RsaOtherPrimesInfo;
@@ -1224,8 +1661,14 @@ interface Text {
 }
 
 declare class TextDecoder {
-  constructor(label?: "utf-8" | "utf8" | "unicode-1-1-utf-8", options?: TextDecoderConstructorOptions);
-  decode(input?: ArrayBuffer, options?: TextDecoderDecodeOptions): string;
+  constructor(
+    label?: "utf-8" | "utf8" | "unicode-1-1-utf-8",
+    options?: TextDecoderConstructorOptions
+  );
+  decode(
+    input?: ArrayBuffer | ArrayBufferView,
+    options?: TextDecoderDecodeOptions
+  ): string;
   readonly encoding: string;
   readonly fatal: boolean;
   readonly ignoreBOM: boolean;
@@ -1276,6 +1719,52 @@ declare class URL {
   toJSON(): string;
 }
 
+declare class URLPattern {
+  constructor(input?: string | URLPatternURLPatternInit, baseURL?: string);
+  readonly protocol: string;
+  readonly username: string;
+  readonly password: string;
+  readonly hostname: string;
+  readonly port: string;
+  readonly pathname: string;
+  readonly search: string;
+  readonly hash: string;
+  test(input?: string | URLPatternURLPatternInit, baseURL?: string): boolean;
+  exec(
+    input?: string | URLPatternURLPatternInit,
+    baseURL?: string
+  ): URLPatternURLPatternResult | null;
+}
+
+interface URLPatternURLPatternComponentResult {
+  input: string;
+  groups: Record<string, string>;
+}
+
+interface URLPatternURLPatternInit {
+  protocol?: string;
+  username?: string;
+  password?: string;
+  hostname?: string;
+  port?: string;
+  pathname?: string;
+  search?: string;
+  hash?: string;
+  baseURL?: string;
+}
+
+interface URLPatternURLPatternResult {
+  inputs: (string | URLPatternURLPatternInit)[];
+  protocol: URLPatternURLPatternComponentResult;
+  username: URLPatternURLPatternComponentResult;
+  password: URLPatternURLPatternComponentResult;
+  hostname: URLPatternURLPatternComponentResult;
+  port: URLPatternURLPatternComponentResult;
+  pathname: URLPatternURLPatternComponentResult;
+  search: URLPatternURLPatternComponentResult;
+  hash: URLPatternURLPatternComponentResult;
+}
+
 declare class URLSearchParams {
   constructor(init?: URLSearchParamsInit);
   append(name: string, value: string): void;
@@ -1288,12 +1777,24 @@ declare class URLSearchParams {
   entries(): IterableIterator<[key: string, value: string]>;
   keys(): IterableIterator<string>;
   values(): IterableIterator<string>;
-  forEach<This = unknown>(callback: (this: This, key: string, value: string, parent: URLSearchParams) => void, thisArg?: This): void;
+  forEach<This = unknown>(
+    callback: (
+      this: This,
+      key: string,
+      value: string,
+      parent: URLSearchParams
+    ) => void,
+    thisArg?: This
+  ): void;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
   toString(): string;
 }
 
-declare type URLSearchParamsInit = URLSearchParams | string | Record<string, string> | ([key: string, value: string])[];
+declare type URLSearchParamsInit =
+  | URLSearchParams
+  | string
+  | Record<string, string>
+  | [key: string, value: string][];
 
 /**
  * Back compat for code migrating to older definitions.
@@ -1303,21 +1804,38 @@ declare type URLSearchParamsInit = URLSearchParams | string | Record<string, str
  */
 declare type URLSearchParamsInitializer = URLSearchParamsInit;
 
-declare abstract class WebSocket extends EventTarget<WebSocketEventMap> {
+declare class WebSocket extends EventTarget<WebSocketEventMap> {
+  constructor(url: string, protocols?: string[] | string);
   accept(): void;
-  send(message: ArrayBuffer | string): void;
+  send(message: ArrayBuffer | ArrayBufferView | string): void;
   close(code?: number, reason?: string): void;
-}
-
-declare type WebSocketEventMap = { close: CloseEvent; message: MessageEvent; error: Event; };
-
-declare const WebSocketPair: { new(): { 0: WebSocket; 1: WebSocket; }; };
+  static readonly READY_STATE_CONNECTING: number;
+  static readonly READY_STATE_OPEN: number;
+  static readonly READY_STATE_CLOSING: number;
+  static readonly READY_STATE_CLOSED: number;
+  readonly readyState: number;
+  readonly url: string | null;
+  readonly protocol: string | null;
+  readonly extensions: string | null;
+}
+
+declare type WebSocketEventMap = {
+  close: CloseEvent;
+  message: MessageEvent;
+  open: Event;
+  error: ErrorEvent;
+};
 
-declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {
+declare const WebSocketPair: { new (): { 0: WebSocket; 1: WebSocket } };
 
-}
+declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {}
 
-declare type WorkerGlobalScopeEventMap = { fetch: FetchEvent; scheduled: ScheduledEvent; unhandledrejection: PromiseRejectionEvent; rejectionhandled: PromiseRejectionEvent; };
+declare type WorkerGlobalScopeEventMap = {
+  fetch: FetchEvent;
+  scheduled: ScheduledEvent;
+  unhandledrejection: PromiseRejectionEvent;
+  rejectionhandled: PromiseRejectionEvent;
+};
 
 declare class WritableStream {
   constructor(underlyingSink?: Object, queuingStrategy?: Object);
@@ -1327,7 +1845,7 @@ declare class WritableStream {
   getWriter(): WritableStreamDefaultWriter;
 }
 
-interface WritableStreamDefaultController {
+declare abstract class WritableStreamDefaultController {
   readonly signal: AbortSignal;
   error(reason?: any): void;
 }
@@ -1347,9 +1865,14 @@ declare class WritableStreamDefaultWriter {
  * Back-compat alias.
  * @deprecated Use WritableStreamDefaultWriter
  */
-declare type WritableStreamWritableStreamDefaultWriter = WritableStreamDefaultWriter;
+declare type WritableStreamWritableStreamDefaultWriter =
+  WritableStreamDefaultWriter;
 
-declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(type: Type, handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>, options?: EventTargetAddEventListenerOptions | boolean): void;
+declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(
+  type: Type,
+  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
+  options?: EventTargetAddEventListenerOptions | boolean
+): void;
 
 declare function atob(data: string): string;
 
@@ -1365,25 +1888,49 @@ declare const console: Console;
 
 declare const crypto: Crypto;
 
-declare function dispatchEvent(event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]): boolean;
+declare function dispatchEvent(
+  event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]
+): boolean;
+
+declare function fetch(
+  request: Request | string,
+  requestInitr?: RequestInit | Request
+): Promise<Response>;
 
-declare function fetch(request: Request | string, requestInitr?: RequestInit | Request): Promise<Response>;
+declare const navigator: Navigator;
 
 declare const origin: void;
 
 declare function queueMicrotask(task: Function): void;
 
-declare function removeEventListener<Type extends keyof WorkerGlobalScopeEventMap>(type: Type, handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
+declare function removeEventListener<
+  Type extends keyof WorkerGlobalScopeEventMap
+>(
+  type: Type,
+  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
+  options?: EventTargetEventListenerOptions | boolean
+): void;
 
 declare const scheduler: Scheduler;
 
 declare const self: ServiceWorkerGlobalScope;
 
-declare function setInterval<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+declare function setInterval<Args extends any[]>(
+  callback: (...args: Args) => void,
+  msDelay?: number,
+  ...args: Args
+): number;
 
-declare function setTimeout<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+declare function setTimeout<Args extends any[]>(
+  callback: (...args: Args) => void,
+  msDelay?: number,
+  ...args: Args
+): number;
 
-declare function structuredClone(value: any, options?: ServiceWorkerGlobalScopeStructuredCloneOptions): any;
+declare function structuredClone(
+  value: any,
+  options?: ServiceWorkerGlobalScopeStructuredCloneOptions
+): any;
 
 /*** Injected pages.d.ts ***/
 type Params<P extends string = any> = Record<P, string | string[]>;
@@ -1392,7 +1939,7 @@ type EventContext<Env, P extends string, Data> = {
   request: Request;
   waitUntil: (promise: Promise<any>) => void;
   next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
-  env: Env & { ASSETS: { fetch: typeof fetch }};
+  env: Env & { ASSETS: { fetch: typeof fetch } };
   params: Params<P>;
   data: Data;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cloudflare/workers-types",
-  "version": "3.3.0",
+  "version": "3.5.0",
   "description": "TypeScript typings for Cloudflare Workers",
   "repository": {
     "type": "git",
@@ -13,17 +13,21 @@
   "scripts": {
     "export:docs": "node -r esbuild-register export/docs.ts",
     "export:overrides": "node -r esbuild-register export/overrides.ts",
+    "prettier:check": "prettier --check '**/*.{md,ts}'",
+    "prettier": "prettier --write '**/*.{md,ts}'",
     "test": "tsc"
   },
   "author": "Cloudflare Workers Team <workers@cloudflare.com> (https://workers.cloudflare.com)",
   "license": "BSD-3-Clause",
   "devDependencies": {
-    "@types/marked": "^3.0.0",
+    "@changesets/changelog-github": "^0.4.2",
+    "@changesets/cli": "^2.18.1",
+    "@types/marked": "^4.0.1",
     "@types/node": "^16.6.1",
     "esbuild": "^0.12.22",
     "esbuild-register": "^3.0.0",
-    "marked": "^3.0.2",
-    "prettier": "2.0.5",
+    "marked": "^4.0.10",
+    "prettier": "^2.5.1",
     "typescript": "^4.3.5"
   }
 }