@cloudflare/workers-types 3.18.0 → 4.20221111.1

package/index.d.ts

@@ -1,247 +1,25 @@
-// This file is auto-generated. DO NOT MODIFY.
-// Please refer to the Auto-Generation section of the README.md.
-
-declare class AbortController {
-  constructor();
-  readonly signal: AbortSignal;
-  abort(reason?: any): void;
-}
-
-declare class AbortSignal extends EventTarget {
-  constructor();
-  static abort(reason?: any): AbortSignal;
-  static timeout(delay: number): AbortSignal;
-  readonly aborted: boolean;
-  readonly reason: any;
-  throwIfAborted(): void;
-}
-
-declare class Blob {
-  constructor(bits?: BlobBits, options?: BlobOptions);
-  readonly size: number;
-  readonly type: string;
-  slice(start?: number, end?: number, type?: string): Blob;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  text(): Promise<string>;
-  stream(): ReadableStream;
-}
-
-declare type BlobBits = (ArrayBuffer | string | Blob)[];
-
-interface BlobOptions {
-  type?: string;
-}
-
-declare abstract class Body {
-  readonly body: ReadableStream | null;
-  readonly bodyUsed: boolean;
-  arrayBuffer(): Promise<ArrayBuffer>;
-  text(): Promise<string>;
-  json<T>(): Promise<T>;
-  formData(): Promise<FormData>;
-  blob(): Promise<Blob>;
-}
-
-declare type BodyInit =
-  | ReadableStream
-  | string
-  | ArrayBuffer
-  | Blob
-  | URLSearchParams
-  | FormData;
-
-/**
- * Back compat for code migrating to older definitions.
- * @deprecated Use BodyInit instead.
- */
-declare type BodyInitializer = BodyInit;
-
-declare class ByteLengthQueuingStrategy {
-  constructor(init: QueuingStrategyInit);
-  readonly highWaterMark: number;
-  size(chunk?: any): number;
-}
-
-declare abstract class Cache {
-  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>;
-}
-
-interface CacheQueryOptions {
-  ignoreMethod?: boolean;
-}
-
-declare abstract class CacheStorage {
-  open(cacheName: string): Promise<Cache>;
-  readonly default: Cache;
-}
-
-interface CfRequestInit extends Omit<RequestInit, "cf"> {
-  cf?: RequestInitCfProperties;
-}
-
-/**
- * Back compat support with older types.
- * @deprecated Use CfRequestInit instead.
- */
-declare type CfRequestInitializerDict = CfRequestInit;
-
-declare class CloseEvent extends Event {
-  constructor(type: string, initializer: CloseEventInit);
-  readonly code: number;
-  readonly reason: string;
-  readonly wasClean: boolean;
-}
-
-interface CloseEventInit {
-  code?: number;
-  reason?: string;
-  wasClean?: boolean;
-}
-
-/**
- * Back compat for code migrating from older definitions.
- * @deprecated Use CloseEventInit instead.
- */
-declare type CloseEventInitializer = CloseEventInit;
-
-interface Comment {
-  text: string;
-  readonly removed: boolean;
-  before(content: Content, options?: ContentOptions): Comment;
-  after(content: Content, options?: ContentOptions): Comment;
-  replace(content: Content, options?: ContentOptions): Comment;
-  remove(): Comment;
-}
-
-declare class CompressionStream extends TransformStream {
-  constructor(format: "gzip" | "deflate");
-}
-
-interface Console {
-  debug(...data: any[]): void;
-  error(...data: any[]): void;
-  info(...data: any[]): void;
-  log(...data: any[]): void;
-  warn(...data: any[]): void;
-}
-
-declare type Content = string | ReadableStream | Response;
-
-interface ContentOptions {
-  html?: boolean;
-}
-
-declare class CountQueuingStrategy {
-  constructor(init: QueuingStrategyInit);
-  readonly highWaterMark: number;
-  size(chunk?: any): number;
-}
-
-declare abstract class Crypto {
-  readonly subtle: SubtleCrypto;
-  getRandomValues<
-    T extends
-      | Int8Array
-      | Uint8Array
-      | Int16Array
-      | Uint16Array
-      | Int32Array
-      | Uint32Array
-      | BigInt64Array
-      | BigUint64Array
-  >(buffer: T): T;
-  randomUUID(): string;
-  DigestStream: typeof DigestStream;
-}
-
-declare abstract class CryptoKey {
-  readonly type: string;
-  readonly extractable: boolean;
-  readonly algorithm: CryptoKeyAlgorithmVariant;
-  readonly usages: string[];
-}
-
-interface CryptoKeyAesKeyAlgorithm {
-  name: string;
-  length: number;
-}
-
-declare type CryptoKeyAlgorithmVariant =
-  | CryptoKeyKeyAlgorithm
-  | CryptoKeyAesKeyAlgorithm
-  | CryptoKeyHmacKeyAlgorithm
-  | CryptoKeyRsaKeyAlgorithm
-  | CryptoKeyEllipticKeyAlgorithm
-  | CryptoKeyArbitraryKeyAlgorithm;
-
-interface CryptoKeyArbitraryKeyAlgorithm {
-  name: string;
-  hash?: CryptoKeyKeyAlgorithm;
-  namedCurve?: string;
-  length?: number;
-}
-
-interface CryptoKeyEllipticKeyAlgorithm {
-  name: string;
-  namedCurve: string;
-}
-
-interface CryptoKeyHmacKeyAlgorithm {
-  name: string;
-  hash: CryptoKeyKeyAlgorithm;
-  length: number;
-}
-
-interface CryptoKeyKeyAlgorithm {
-  name: string;
-}
-
-interface CryptoKeyPair {
-  publicKey: CryptoKey;
-  privateKey: CryptoKey;
-}
-
-interface CryptoKeyRsaKeyAlgorithm {
-  name: string;
-  modulusLength: number;
-  publicExponent: ArrayBuffer;
-  hash?: CryptoKeyKeyAlgorithm;
-}
-
-interface D1Database {
-  prepare(query: string): D1PreparedStatement;
-  dump(): Promise<ArrayBuffer>;
-  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
-  exec<T = unknown>(query: string): Promise<D1Result<T>>;
-}
-
-interface D1PreparedStatement {
-  bind(...values: any[]): D1PreparedStatement;
-  first<T = unknown>(colName?: string): Promise<T>;
-  run<T = unknown>(): Promise<D1Result<T>>;
-  all<T = unknown>(): Promise<D1Result<T>>;
-  raw<T = unknown>(): Promise<T[]>;
-}
-
-declare type D1Result<T = unknown> = {
-  results?: T[];
-  lastRowId: number | null;
-  changes: number;
-  duration: number;
-  error?: string;
-};
-
+/*! *****************************************************************************
+Copyright (c) Cloudflare. All rights reserved.
+Copyright (c) Microsoft Corporation. All rights reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+/* eslint-disable */
+// noinspection JSUnusedGlobalSymbols
 declare class DOMException extends Error {
   constructor(message?: string, name?: string);
+  readonly message: string;
+  readonly name: string;
   readonly code: number;
+  readonly stack: any;
   static readonly INDEX_SIZE_ERR: number;
   static readonly DOMSTRING_SIZE_ERR: number;
   static readonly HIERARCHY_REQUEST_ERR: number;
@@ -268,58 +46,292 @@ declare class DOMException extends Error {
   static readonly INVALID_NODE_TYPE_ERR: number;
   static readonly DATA_CLONE_ERR: number;
 }
-
-declare class DecompressionStream extends TransformStream {
-  constructor(format: "gzip" | "deflate");
+declare type WorkerGlobalScopeEventMap = {
+  fetch: FetchEvent;
+  scheduled: ScheduledEvent;
+  unhandledrejection: PromiseRejectionEvent;
+  rejectionhandled: PromiseRejectionEvent;
+};
+declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {
+  EventTarget: typeof EventTarget;
+}
+declare interface Console {
+  "assert"(condition?: boolean, ...data: any[]): void;
+  clear(): void;
+  count(label?: string): void;
+  countReset(label?: string): void;
+  debug(...data: any[]): void;
+  dir(item?: any, options?: any): void;
+  dirxml(...data: any[]): void;
+  error(...data: any[]): void;
+  group(...data: any[]): void;
+  groupCollapsed(...data: any[]): void;
+  groupEnd(): void;
+  info(...data: any[]): void;
+  log(...data: any[]): void;
+  table(tabularData?: any, properties?: string[]): void;
+  time(label?: string): void;
+  timeEnd(label?: string): void;
+  timeLog(label?: string, ...data: any[]): void;
+  timeStamp(label?: string): void;
+  trace(...data: any[]): void;
+  warn(...data: any[]): void;
 }
-
-declare class DigestStream extends WritableStream {
-  constructor(algorithm: string | SubtleCryptoHashAlgorithm);
-  readonly digest: Promise<ArrayBuffer>;
+declare const console: Console;
+declare type BufferSource = ArrayBufferView | ArrayBuffer;
+declare namespace WebAssembly {
+  class CompileError extends Error {
+    constructor(message?: string);
+  }
+  class RuntimeError extends Error {
+    constructor(message?: string);
+  }
+  type ValueType =
+    | "anyfunc"
+    | "externref"
+    | "f32"
+    | "f64"
+    | "i32"
+    | "i64"
+    | "v128";
+  interface GlobalDescriptor {
+    value: ValueType;
+    mutable?: boolean;
+  }
+  class Global {
+    constructor(descriptor: GlobalDescriptor, value?: any);
+    value: any;
+    valueOf(): any;
+  }
+  type ImportValue = ExportValue | number;
+  type ModuleImports = Record<string, ImportValue>;
+  type Imports = Record<string, ModuleImports>;
+  type ExportValue = Function | Global | Memory | Table;
+  type Exports = Record<string, ExportValue>;
+  class Instance {
+    constructor(module: Module, imports?: Imports);
+    readonly exports: Exports;
+  }
+  interface MemoryDescriptor {
+    initial: number;
+    maximum?: number;
+    shared?: boolean;
+  }
+  class Memory {
+    constructor(descriptor: MemoryDescriptor);
+    readonly buffer: ArrayBuffer;
+    grow(delta: number): number;
+  }
+  type ImportExportKind = "function" | "global" | "memory" | "table";
+  interface ModuleExportDescriptor {
+    kind: ImportExportKind;
+    name: string;
+  }
+  interface ModuleImportDescriptor {
+    kind: ImportExportKind;
+    module: string;
+    name: string;
+  }
+  abstract class Module {
+    static customSections(module: Module, sectionName: string): ArrayBuffer[];
+    static exports(module: Module): ModuleExportDescriptor[];
+    static imports(module: Module): ModuleImportDescriptor[];
+  }
+  type TableKind = "anyfunc" | "externref";
+  interface TableDescriptor {
+    element: TableKind;
+    initial: number;
+    maximum?: number;
+  }
+  class Table {
+    constructor(descriptor: TableDescriptor, value?: any);
+    readonly length: number;
+    get(index: number): any;
+    grow(delta: number, value?: any): number;
+    set(index: number, value?: any): void;
+  }
+  function instantiate(module: Module, imports?: Imports): Promise<Instance>;
+  function validate(bytes: BufferSource): boolean;
+}
+/** This ServiceWorker API interface represents the global execution context of a service worker. */
+declare interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
+  DOMException: typeof DOMException;
+  WorkerGlobalScope: typeof WorkerGlobalScope;
+  btoa(data: string): string;
+  atob(data: string): string;
+  setTimeout(callback: (...args: any[]) => void, msDelay?: number): number;
+  setTimeout<Args extends any[]>(
+    callback: (...args: Args) => void,
+    msDelay?: number,
+    ...args: Args
+  ): number;
+  clearTimeout(timeoutId: number | null): void;
+  setInterval(callback: (...args: any[]) => void, msDelay?: number): number;
+  setInterval<Args extends any[]>(
+    callback: (...args: Args) => void,
+    msDelay?: number,
+    ...args: Args
+  ): number;
+  clearInterval(timeoutId: number | null): void;
+  queueMicrotask(task: Function): void;
+  structuredClone<T>(value: T, options?: StructuredSerializeOptions): T;
+  fetch(
+    input: RequestInfo,
+    init?: RequestInit<RequestInitCfProperties>
+  ): Promise<Response>;
+  self: ServiceWorkerGlobalScope;
+  crypto: Crypto;
+  caches: CacheStorage;
+  scheduler: Scheduler;
+  Event: typeof Event;
+  ExtendableEvent: typeof ExtendableEvent;
+  PromiseRejectionEvent: typeof PromiseRejectionEvent;
+  FetchEvent: typeof FetchEvent;
+  TraceEvent: typeof TraceEvent;
+  ScheduledEvent: typeof ScheduledEvent;
+  MessageEvent: typeof MessageEvent;
+  CloseEvent: typeof CloseEvent;
+  ReadableStreamDefaultReader: typeof ReadableStreamDefaultReader;
+  ReadableStreamBYOBReader: typeof ReadableStreamBYOBReader;
+  ReadableStream: typeof ReadableStream;
+  WritableStream: typeof WritableStream;
+  WritableStreamDefaultWriter: typeof WritableStreamDefaultWriter;
+  TransformStream: typeof TransformStream;
+  ByteLengthQueuingStrategy: typeof ByteLengthQueuingStrategy;
+  CountQueuingStrategy: typeof CountQueuingStrategy;
+  CompressionStream: typeof CompressionStream;
+  DecompressionStream: typeof DecompressionStream;
+  TextEncoderStream: typeof TextEncoderStream;
+  TextDecoderStream: typeof TextDecoderStream;
+  Headers: typeof Headers;
+  Body: typeof Body;
+  Request: typeof Request;
+  Response: typeof Response;
+  WebSocket: typeof WebSocket;
+  WebSocketPair: typeof WebSocketPair;
+  AbortController: typeof AbortController;
+  AbortSignal: typeof AbortSignal;
+  TextDecoder: typeof TextDecoder;
+  TextEncoder: typeof TextEncoder;
+  URL: typeof URL;
+  URLSearchParams: typeof URLSearchParams;
+  URLPattern: typeof URLPattern;
+  Blob: typeof Blob;
+  File: typeof File;
+  FormData: typeof FormData;
+  Crypto: typeof Crypto;
+  SubtleCrypto: typeof SubtleCrypto;
+  CryptoKey: typeof CryptoKey;
+  CacheStorage: typeof CacheStorage;
+  Cache: typeof Cache;
+  FixedLengthStream: typeof FixedLengthStream;
+  IdentityTransformStream: typeof IdentityTransformStream;
+  HTMLRewriter: typeof HTMLRewriter;
+  connect(address: string, options?: SocketOptions): Socket;
 }
-
-interface Doctype {
-  readonly name: string | null;
-  readonly publicId: string | null;
-  readonly systemId: string | null;
+declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(
+  type: Type,
+  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
+  options?: EventTargetAddEventListenerOptions | boolean
+): void;
+declare function removeEventListener<
+  Type extends keyof WorkerGlobalScopeEventMap
+>(
+  type: Type,
+  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
+  options?: EventTargetEventListenerOptions | boolean
+): void;
+/** Dispatches a synthetic event event to target and returns true if either event's cancelable attribute value is false or its preventDefault() method was not invoked, and false otherwise. */
+declare function dispatchEvent(
+  event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]
+): boolean;
+declare function btoa(data: string): string;
+declare function atob(data: string): string;
+declare function setTimeout(
+  callback: (...args: any[]) => void,
+  msDelay?: number
+): number;
+declare function setTimeout<Args extends any[]>(
+  callback: (...args: Args) => void,
+  msDelay?: number,
+  ...args: Args
+): number;
+declare function clearTimeout(timeoutId: number | null): void;
+declare function setInterval(
+  callback: (...args: any[]) => void,
+  msDelay?: number
+): number;
+declare function setInterval<Args extends any[]>(
+  callback: (...args: Args) => void,
+  msDelay?: number,
+  ...args: Args
+): number;
+declare function clearInterval(timeoutId: number | null): void;
+declare function queueMicrotask(task: Function): void;
+declare function structuredClone<T>(
+  value: T,
+  options?: StructuredSerializeOptions
+): T;
+declare function fetch(
+  input: RequestInfo,
+  init?: RequestInit<RequestInitCfProperties>
+): Promise<Response>;
+declare const self: ServiceWorkerGlobalScope;
+declare const crypto: Crypto;
+declare const caches: CacheStorage;
+declare const scheduler: Scheduler;
+declare function connect(address: string, options?: SocketOptions): Socket;
+declare interface ExecutionContext {
+  waitUntil(promise: void | Promise<void>): void;
+  passThroughOnException(): void;
 }
-
-interface DocumentEnd {
-  append(content: Content, options?: ContentOptions): DocumentEnd;
+declare type ExportedHandlerFetchHandler<Env = unknown> = (
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext
+) => Response | Promise<Response>;
+declare type ExportedHandlerTraceHandler<Env = unknown> = (
+  traces: TraceItem[],
+  env: Env,
+  ctx: ExecutionContext
+) => void | Promise<void>;
+declare type ExportedHandlerScheduledHandler<Env = unknown> = (
+  controller: ScheduledController,
+  env: Env,
+  ctx: ExecutionContext
+) => void | Promise<void>;
+declare type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
+  batch: MessageBatch<Message>,
+  env: Env,
+  ctx: ExecutionContext
+) => void | Promise<void>;
+declare interface ExportedHandler<Env = unknown, QueueMessage = unknown> {
+  fetch?: ExportedHandlerFetchHandler<Env>;
+  trace?: ExportedHandlerTraceHandler<Env>;
+  scheduled?: ExportedHandlerScheduledHandler<Env>;
+  queue?: ExportedHandlerQueueHandler<Env, QueueMessage>;
 }
-
-interface DurableObject {
-  fetch(request: Request): Promise<Response>;
-  alarm?(): Promise<void>;
+declare interface StructuredSerializeOptions {
+  transfer?: any[];
 }
-
-interface DurableObjectGetAlarmOptions {
-  allowConcurrency?: boolean;
+declare abstract class PromiseRejectionEvent extends Event {
+  readonly promise: Promise<any>;
+  readonly reason: any;
 }
-
-interface DurableObjectGetOptions {
-  allowConcurrency?: boolean;
-  noCache?: boolean;
+declare interface DurableObject {
+  fetch(request: Request): Response | Promise<Response>;
+  alarm?(): void | Promise<void>;
 }
-
-interface DurableObjectId {
+declare interface DurableObjectStub extends Fetcher {
+  readonly id: DurableObjectId;
+  readonly name?: string;
+}
+declare interface DurableObjectId {
   toString(): string;
   equals(other: DurableObjectId): boolean;
   readonly name?: string;
 }
-
-interface DurableObjectListOptions {
-  start?: string;
-  startAfter?: string;
-  end?: string;
-  prefix?: string;
-  reverse?: boolean;
-  limit?: number;
-  allowConcurrency?: boolean;
-  noCache?: boolean;
-}
-
-interface DurableObjectNamespace {
+declare interface DurableObjectNamespace {
   newUniqueId(
     options?: DurableObjectNamespaceNewUniqueIdOptions
   ): DurableObjectId;
@@ -327,30 +339,16 @@ interface DurableObjectNamespace {
   idFromString(id: string): DurableObjectId;
   get(id: DurableObjectId): DurableObjectStub;
 }
-
-interface DurableObjectNamespaceNewUniqueIdOptions {
+declare interface DurableObjectNamespaceNewUniqueIdOptions {
   jurisdiction?: string;
 }
-
-interface DurableObjectPutOptions {
-  allowConcurrency?: boolean;
-  allowUnconfirmed?: boolean;
-  noCache?: boolean;
-}
-
-interface DurableObjectSetAlarmOptions {
-  allowConcurrency?: boolean;
-  allowUnconfirmed?: boolean;
-}
-
-interface DurableObjectState {
-  waitUntil(promise: Promise<any>): void;
-  id: DurableObjectId;
+declare interface DurableObjectState {
+  waitUntil(promise: void | Promise<void>): void;
+  readonly id: DurableObjectId;
   readonly storage: DurableObjectStorage;
   blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
 }
-
-interface DurableObjectStorage {
+declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
     options?: DurableObjectGetOptions
@@ -373,44 +371,15 @@ interface DurableObjectStorage {
   ): 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>;
+  rollback(): void;
   getAlarm(options?: DurableObjectGetAlarmOptions): Promise<number | null>;
   setAlarm(
     scheduledTime: number | Date,
     options?: DurableObjectSetAlarmOptions
   ): Promise<void>;
   deleteAlarm(options?: DurableObjectSetAlarmOptions): Promise<void>;
-  sync(): Promise<void>;
-}
-
-/**
- *
- * @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 workers-types 3.x. Scheduled for removal.
- */
-declare type DurableObjectStorageOperationsListOptions =
-  DurableObjectListOptions;
-
-/**
- *
- * @deprecated Don't use. Introduced incidentally in workers-types 3.x. Scheduled for removal.
- */
-declare type DurableObjectStorageOperationsPutOptions = DurableObjectPutOptions;
-
-interface DurableObjectStub extends Fetcher {
-  readonly id: DurableObjectId;
-  readonly name?: string;
 }
-
-interface DurableObjectTransaction {
+declare interface DurableObjectStorage {
   get<T = unknown>(
     key: string,
     options?: DurableObjectGetOptions
@@ -433,62 +402,75 @@ interface DurableObjectTransaction {
   ): Promise<void>;
   delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
   delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
-  rollback(): void;
+  deleteAll(options?: DurableObjectPutOptions): Promise<void>;
+  transaction<T>(
+    closure: (txn: DurableObjectTransaction) => Promise<T>
+  ): Promise<T>;
   getAlarm(options?: DurableObjectGetAlarmOptions): Promise<number | null>;
   setAlarm(
     scheduledTime: number | Date,
     options?: DurableObjectSetAlarmOptions
   ): Promise<void>;
   deleteAlarm(options?: DurableObjectSetAlarmOptions): Promise<void>;
+  sync(): Promise<void>;
 }
-
-interface Element {
-  tagName: string;
-  readonly attributes: IterableIterator<string[]>;
-  readonly removed: boolean;
-  readonly namespaceURI: string;
-  getAttribute(name: string): string | null;
-  hasAttribute(name: string): boolean;
-  setAttribute(name: string, value: string): Element;
-  removeAttribute(name: string): Element;
-  before(content: Content, options?: ContentOptions): Element;
-  after(content: Content, options?: ContentOptions): Element;
-  prepend(content: Content, options?: ContentOptions): Element;
-  append(content: Content, options?: ContentOptions): Element;
-  replace(content: Content, options?: ContentOptions): Element;
-  remove(): Element;
-  removeAndKeepContent(): Element;
-  setInnerContent(content: Content, options?: ContentOptions): Element;
-  onEndTag(handler: (tag: EndTag) => void | Promise<void>): void;
+declare interface DurableObjectListOptions {
+  start?: string;
+  startAfter?: string;
+  end?: string;
+  prefix?: string;
+  reverse?: boolean;
+  limit?: number;
+  allowConcurrency?: boolean;
+  noCache?: boolean;
 }
-
-interface EndTag {
-  name: string;
-  before(content: Content, options?: ContentOptions): EndTag;
-  after(content: Content, options?: ContentOptions): EndTag;
-  remove(): EndTag;
+declare interface DurableObjectGetOptions {
+  allowConcurrency?: boolean;
+  noCache?: boolean;
+}
+declare interface DurableObjectGetAlarmOptions {
+  allowConcurrency?: boolean;
+}
+declare interface DurableObjectPutOptions {
+  allowConcurrency?: boolean;
+  allowUnconfirmed?: boolean;
+  noCache?: boolean;
+}
+declare interface DurableObjectSetAlarmOptions {
+  allowConcurrency?: boolean;
+  allowUnconfirmed?: boolean;
 }
-
-interface ErrorEvent extends Event {
-  readonly filename: string;
-  readonly message: string;
-  readonly lineno: number;
-  readonly colno: number;
-  readonly error: any;
+declare interface AnalyticsEngineDataset {
+  writeDataPoint(event?: AnalyticsEngineDataPoint): void;
+}
+declare interface AnalyticsEngineDataPoint {
+  indexes?: ((ArrayBuffer | string) | null)[];
+  doubles?: number[];
+  blobs?: ((ArrayBuffer | string) | null)[];
 }
-
 declare class Event {
   constructor(type: string, init?: EventInit);
+  /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
   readonly type: string;
+  /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE. */
   readonly eventPhase: number;
+  /** Returns true or false depending on how event was initialized. True if event invokes listeners past a ShadowRoot node that is the root of its target, and false otherwise. */
   readonly composed: boolean;
+  /** Returns true or false depending on how event was initialized. True if event goes through its target's ancestors in reverse tree order, and false otherwise. */
   readonly bubbles: boolean;
+  /** Returns true or false depending on how event was initialized. Its return value does not always carry meaning, but true can indicate that part of the operation during which event was dispatched, can be canceled by invoking the preventDefault() method. */
   readonly cancelable: boolean;
+  /** Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise. */
   readonly defaultPrevented: boolean;
+  /** @deprecated */
   readonly returnValue: boolean;
+  /** Returns the object whose event listener's callback is currently being invoked. */
   readonly currentTarget?: EventTarget;
+  /** @deprecated */
   readonly srcElement?: EventTarget;
+  /** Returns the event's timestamp as the number of milliseconds measured relative to the time origin. */
   readonly timeStamp: number;
+  /** Returns true if event was dispatched by the user agent, and false otherwise. */
   readonly isTrusted: boolean;
   cancelBubble: boolean;
   stopImmediatePropagation(): void;
@@ -500,25 +482,20 @@ declare class Event {
   static readonly AT_TARGET: number;
   static readonly BUBBLING_PHASE: number;
 }
-
-interface EventInit {
+declare interface EventInit {
   bubbles?: boolean;
   cancelable?: boolean;
   composed?: boolean;
 }
-
 declare type EventListener<EventType extends Event = Event> = (
   event: EventType
 ) => void;
-
-interface EventListenerObject<EventType extends Event = Event> {
+declare interface EventListenerObject<EventType extends Event = Event> {
   handleEvent(event: EventType): void;
 }
-
 declare type EventListenerOrEventListenerObject<
   EventType extends Event = Event
 > = EventListener<EventType> | EventListenerObject<EventType>;
-
 declare class EventTarget<
   EventMap extends Record<string, Event> = Record<string, Event>
 > {
@@ -535,102 +512,342 @@ declare class EventTarget<
   ): void;
   dispatchEvent(event: EventMap[keyof EventMap]): boolean;
 }
-
-interface EventTargetAddEventListenerOptions {
+declare interface EventTargetEventListenerOptions {
+  capture?: boolean;
+}
+declare interface EventTargetAddEventListenerOptions {
   capture?: boolean;
   passive?: boolean;
   once?: boolean;
   signal?: AbortSignal;
 }
-
-interface EventTargetEventListenerOptions {
-  capture?: boolean;
+declare interface EventTargetHandlerObject {
+  handleEvent: (event: Event) => any | undefined;
 }
-
-interface EventTargetHandlerObject {
-  handleEvent(arg1: Event): any | undefined;
+declare class AbortController {
+  constructor();
+  /** Returns the AbortSignal object associated with this object. */
+  readonly signal: AbortSignal;
+  abort(reason?: any): void;
 }
-
-interface ExecutionContext {
-  waitUntil(promise: Promise<any>): void;
-  passThroughOnException(): void;
+declare abstract class AbortSignal extends EventTarget {
+  static abort(reason?: any): AbortSignal;
+  static timeout(delay: number): AbortSignal;
+  /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
+  readonly aborted: boolean;
+  readonly reason: any;
+  throwIfAborted(): void;
 }
-
-interface ExportedHandler<Env = unknown> {
-  fetch?: ExportedHandlerFetchHandler<Env>;
-  scheduled?: ExportedHandlerScheduledHandler<Env>;
+declare interface Scheduler {
+  wait(delay: number, maybeOptions?: SchedulerWaitOptions): Promise<void>;
 }
-
-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 class ExtendableEvent extends Event {
-  constructor(type: string, init?: EventInit);
-  waitUntil(promise: Promise<any>): void;
+declare interface SchedulerWaitOptions {
+  signal?: AbortSignal;
+}
+declare abstract class ExtendableEvent extends Event {
+  waitUntil(promise: void | Promise<void>): void;
+}
+declare class Blob {
+  constructor(
+    bits?: ((ArrayBuffer | ArrayBufferView) | string | Blob)[],
+    options?: BlobOptions
+  );
+  readonly size: number;
+  readonly type: string;
+  slice(start?: number, end?: number, type?: string): Blob;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  stream(): ReadableStream;
+}
+declare interface BlobOptions {
+  type?: string;
+}
+declare class File extends Blob {
+  constructor(
+    bits: ((ArrayBuffer | ArrayBufferView) | string | Blob)[] | undefined,
+    name: string,
+    options?: FileOptions
+  );
+  readonly name: string;
+  readonly lastModified: number;
+}
+declare interface FileOptions {
+  type?: string;
+  lastModified?: number;
+}
+declare abstract class CacheStorage {
+  open(cacheName: string): Promise<Cache>;
+  readonly default: Cache;
+}
+declare abstract class Cache {
+  delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
+  match(
+    request: RequestInfo,
+    options?: CacheQueryOptions
+  ): Promise<Response | undefined>;
+  put(request: RequestInfo, response: Response): Promise<void>;
+}
+declare interface CacheQueryOptions {
+  ignoreMethod?: boolean;
+}
+declare abstract class Crypto {
+  /** Available only in secure contexts. */
+  readonly subtle: SubtleCrypto;
+  getRandomValues<
+    T extends
+      | Int8Array
+      | Uint8Array
+      | Int16Array
+      | Uint16Array
+      | Int32Array
+      | Uint32Array
+      | BigInt64Array
+      | BigUint64Array
+  >(buffer: T): T;
+  randomUUID(): string;
+  DigestStream: typeof DigestStream;
+}
+declare abstract class SubtleCrypto {
+  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 | ArrayBufferView) | 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 | ArrayBufferView,
+    unwrappingKey: CryptoKey,
+    unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm,
+    unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm,
+    extractable: boolean,
+    keyUsages: string[]
+  ): Promise<CryptoKey>;
+  timingSafeEqual(
+    a: ArrayBuffer | ArrayBufferView,
+    b: ArrayBuffer | ArrayBufferView
+  ): boolean;
+}
+declare abstract class CryptoKey {
+  readonly type: string;
+  readonly extractable: boolean;
+  readonly algorithm:
+    | CryptoKeyKeyAlgorithm
+    | CryptoKeyAesKeyAlgorithm
+    | CryptoKeyHmacKeyAlgorithm
+    | CryptoKeyRsaKeyAlgorithm
+    | CryptoKeyEllipticKeyAlgorithm
+    | CryptoKeyArbitraryKeyAlgorithm;
+  readonly usages: string[];
+}
+declare interface CryptoKeyPair {
+  publicKey: CryptoKey;
+  privateKey: CryptoKey;
+}
+declare interface JsonWebKey {
+  kty: string;
+  use?: string;
+  key_ops?: string[];
+  alg?: string;
+  ext?: boolean;
+  crv?: string;
+  x?: string;
+  y?: string;
+  d?: string;
+  n?: string;
+  e?: string;
+  p?: string;
+  q?: string;
+  dp?: string;
+  dq?: string;
+  qi?: string;
+  oth?: RsaOtherPrimesInfo[];
+  k?: string;
+}
+declare interface RsaOtherPrimesInfo {
+  r?: string;
+  d?: string;
+  t?: string;
+}
+declare interface SubtleCryptoDeriveKeyAlgorithm {
+  name: string;
+  salt?: ArrayBuffer;
+  iterations?: number;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  $public?: CryptoKey;
+  info?: ArrayBuffer;
+}
+declare interface SubtleCryptoEncryptAlgorithm {
+  name: string;
+  iv?: ArrayBuffer;
+  additionalData?: ArrayBuffer;
+  tagLength?: number;
+  counter?: ArrayBuffer;
+  length?: number;
+  label?: ArrayBuffer;
+}
+declare interface SubtleCryptoGenerateKeyAlgorithm {
+  name: string;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  modulusLength?: number;
+  publicExponent?: ArrayBuffer;
+  length?: number;
+  namedCurve?: string;
+}
+declare interface SubtleCryptoHashAlgorithm {
+  name: string;
+}
+declare interface SubtleCryptoImportKeyAlgorithm {
+  name: string;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  length?: number;
+  namedCurve?: string;
+  compressed?: boolean;
+}
+declare interface SubtleCryptoSignAlgorithm {
+  name: string;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  dataLength?: number;
+  saltLength?: number;
+}
+declare interface CryptoKeyKeyAlgorithm {
+  name: string;
+}
+declare interface CryptoKeyAesKeyAlgorithm {
+  name: string;
+  length: number;
+}
+declare interface CryptoKeyHmacKeyAlgorithm {
+  name: string;
+  hash: CryptoKeyKeyAlgorithm;
+  length: number;
+}
+declare interface CryptoKeyRsaKeyAlgorithm {
+  name: string;
+  modulusLength: number;
+  publicExponent: ArrayBuffer;
+  hash?: CryptoKeyKeyAlgorithm;
+}
+declare interface CryptoKeyEllipticKeyAlgorithm {
+  name: string;
+  namedCurve: string;
+}
+declare interface CryptoKeyArbitraryKeyAlgorithm {
+  name: string;
+  hash?: CryptoKeyKeyAlgorithm;
+  namedCurve?: string;
+  length?: number;
 }
-
-declare abstract class FetchEvent extends ExtendableEvent {
-  readonly request: Request;
-  respondWith(promise: Response | Promise<Response>): void;
-  passThroughOnException(): void;
+declare class DigestStream extends WritableStream<
+  ArrayBuffer | ArrayBufferView
+> {
+  constructor(algorithm: string | SubtleCryptoHashAlgorithm);
+  readonly digest: Promise<ArrayBuffer>;
 }
-
-declare abstract class Fetcher {
-  fetch(
-    requestOrUrl: Request | string,
-    requestInit?: RequestInit | Request
-  ): Promise<Response>;
+declare class TextDecoder {
+  constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  decode(
+    input?: ArrayBuffer | ArrayBufferView,
+    options?: TextDecoderDecodeOptions
+  ): string;
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
 }
-
-declare class File extends Blob {
-  constructor(bits?: BlobBits, name?: string, options?: FileOptions);
-  readonly name: string;
-  readonly lastModified: number;
+declare class TextEncoder {
+  constructor();
+  encode(input?: string): Uint8Array;
+  encodeInto(input: string, buffer: Uint8Array): TextEncoderEncodeIntoResult;
+  readonly encoding: string;
 }
-
-interface FileOptions {
-  type?: string;
-  lastModified?: number;
+declare interface TextDecoderConstructorOptions {
+  fatal: boolean;
+  ignoreBOM: boolean;
 }
-
-declare class FixedLengthStream extends IdentityTransformStream {
-  constructor(expectedLength: number | bigint);
+declare interface TextDecoderDecodeOptions {
+  stream: boolean;
+}
+declare interface TextEncoderEncodeIntoResult {
+  read: number;
+  written: number;
 }
-
 declare class FormData {
   constructor();
   append(name: string, value: string): void;
   append(name: string, value: Blob, filename?: string): void;
   delete(name: string): void;
-  get(name: string): File | string | null;
-  getAll(name: string): (File | string)[];
+  get(name: string): string | null;
+  getAll(name: string): string[];
   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: string]>;
   keys(): IterableIterator<string>;
-  values(): IterableIterator<string | File>;
+  values(): IterableIterator<File | string>;
   forEach<This = unknown>(
     callback: (
       this: This,
-      value: File | string,
+      value: string,
       key: string,
       parent: FormData
     ) => void,
     thisArg?: This
   ): void;
-  [Symbol.iterator](): IterableIterator<[key: string, value: File | string]>;
+  [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
+}
+declare interface ContentOptions {
+  html?: boolean;
 }
-
 declare class HTMLRewriter {
   constructor();
   on(
@@ -640,20 +857,76 @@ declare class HTMLRewriter {
   onDocument(handlers: HTMLRewriterDocumentContentHandlers): HTMLRewriter;
   transform(response: Response): Response;
 }
-
-interface HTMLRewriterDocumentContentHandlers {
+declare interface HTMLRewriterElementContentHandlers {
+  element?(element: Element): void | Promise<void>;
+  comments?(comment: Comment): void | Promise<void>;
+  text?(element: Text): void | Promise<void>;
+}
+declare interface HTMLRewriterDocumentContentHandlers {
   doctype?(doctype: Doctype): void | Promise<void>;
   comments?(comment: Comment): void | Promise<void>;
   text?(text: Text): void | Promise<void>;
   end?(end: DocumentEnd): void | Promise<void>;
 }
-
-interface HTMLRewriterElementContentHandlers {
-  element?(element: Element): void | Promise<void>;
-  comments?(comment: Comment): void | Promise<void>;
-  text?(text: Text): void | Promise<void>;
+declare interface Doctype {
+  readonly name: string | null;
+  readonly publicId: string | null;
+  readonly systemId: string | null;
 }
-
+declare interface Element {
+  tagName: string;
+  readonly attributes: IterableIterator<string[]>;
+  readonly removed: boolean;
+  readonly namespaceURI: string;
+  getAttribute(name: string): string | null;
+  hasAttribute(name: string): boolean;
+  setAttribute(name: string, value: string): Element;
+  removeAttribute(name: string): Element;
+  before(content: string, options?: ContentOptions): Element;
+  after(content: string, options?: ContentOptions): Element;
+  prepend(content: string, options?: ContentOptions): Element;
+  append(content: string, options?: ContentOptions): Element;
+  replace(content: string, options?: ContentOptions): Element;
+  remove(): Element;
+  removeAndKeepContent(): Element;
+  setInnerContent(content: string, options?: ContentOptions): Element;
+  onEndTag(handler: (tag: EndTag) => void | Promise<void>): void;
+}
+declare interface EndTag {
+  name: string;
+  before(content: string, options?: ContentOptions): EndTag;
+  after(content: string, options?: ContentOptions): EndTag;
+  remove(): EndTag;
+}
+declare interface Comment {
+  text: string;
+  readonly removed: boolean;
+  before(content: string, options?: ContentOptions): Comment;
+  after(content: string, options?: ContentOptions): Comment;
+  replace(content: string, options?: ContentOptions): Comment;
+  remove(): Comment;
+}
+declare interface Text {
+  readonly text: string;
+  readonly lastInTextNode: boolean;
+  readonly removed: boolean;
+  before(content: string, options?: ContentOptions): Text;
+  after(content: string, options?: ContentOptions): Text;
+  replace(content: string, options?: ContentOptions): Text;
+  remove(): Text;
+}
+declare interface DocumentEnd {
+  append(content: string, options?: ContentOptions): DocumentEnd;
+}
+declare abstract class FetchEvent extends ExtendableEvent {
+  readonly request: Request;
+  respondWith(promise: Response | Promise<Response>): void;
+  passThroughOnException(): void;
+}
+declare type HeadersInit =
+  | Headers
+  | Iterable<Iterable<string>>
+  | Record<string, string>;
 declare class Headers {
   constructor(init?: HeadersInit);
   get(name: string): string | null;
@@ -671,217 +944,219 @@ declare class Headers {
   values(): IterableIterator<string>;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
 }
-
-declare type HeadersInit =
-  | Headers
-  | Record<string, string>
-  | [key: string, value: string][];
-
-/**
- * Back compat for code migrating to older definitions.
- * @deprecated Use HeadersInit instead.
- */
-declare type HeadersInitializer = HeadersInit;
-
-declare class IdentityTransformStream extends TransformStream {
-  constructor();
+declare type BodyInit =
+  | ReadableStream<Uint8Array>
+  | string
+  | ArrayBuffer
+  | ArrayBufferView
+  | Blob
+  | URLSearchParams
+  | FormData;
+declare abstract class Body {
+  readonly body: ReadableStream | null;
+  readonly bodyUsed: boolean;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  text(): Promise<string>;
+  json<T>(): Promise<T>;
+  formData(): Promise<FormData>;
+  blob(): Promise<Blob>;
 }
-
-interface JsonWebKey {
-  kty: string;
-  use?: string;
-  key_ops?: string[];
-  alg?: string;
-  ext?: boolean;
-  crv?: string;
-  x?: string;
-  y?: string;
-  d?: string;
-  n?: string;
-  e?: string;
-  p?: string;
-  q?: string;
-  dp?: string;
-  dq?: string;
-  qi?: string;
-  oth?: RsaOtherPrimesInfo[];
-  k?: string;
+declare class Response extends Body {
+  constructor(body?: BodyInit | null, init?: ResponseInit);
+  static redirect(url: string, status?: number): Response;
+  static json(any: any, maybeInit?: ResponseInit | Response): Response;
+  clone(): Response;
+  readonly status: number;
+  readonly statusText: string;
+  readonly headers: Headers;
+  readonly ok: boolean;
+  readonly redirected: boolean;
+  readonly url: string;
+  readonly webSocket: WebSocket | null;
+  readonly cf?: any;
 }
-
-/**
- * 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<K extends string = string> {
+declare interface ResponseInit {
+  status?: number;
+  statusText?: string;
+  headers?: HeadersInit;
+  cf?: any;
+  webSocket?: WebSocket | null;
+  encodeBody?: "automatic" | "manual";
+}
+declare type RequestInfo = Request | string | URL;
+declare class Request<CfHostMetadata = unknown> extends Body {
+  constructor(input: RequestInfo, init?: RequestInit);
+  clone(): Request<CfHostMetadata>;
+  /** Returns request's HTTP method, which is "GET" by default. */
+  readonly method: string;
+  /** Returns the URL of request as a string. */
+  readonly url: string;
+  /** Returns a Headers object consisting of the headers associated with request. Note that headers added in the network layer by the user agent will not be accounted for in this object, e.g., the "Host" header. */
+  readonly headers: Headers;
+  /** Returns the redirect mode associated with request, which is a string indicating how redirects for the request will be handled during fetching. A request will follow redirects by default. */
+  readonly redirect: string;
+  readonly fetcher: Fetcher | null;
+  /** Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler. */
+  readonly signal: AbortSignal;
+  readonly cf?: IncomingRequestCfProperties<CfHostMetadata>;
+}
+declare interface RequestInit<
+  CfType = IncomingRequestCfProperties | RequestInitCfProperties
+> {
+  /** A string to set request's method. */
+  method?: string;
+  /** A Headers object, an object literal, or an array of two-item arrays to set request's headers. */
+  headers?: HeadersInit;
+  /** A BodyInit object or null to set request's body. */
+  body?: BodyInit | null;
+  /** A string indicating whether request follows redirects, results in an error upon encountering a redirect, or returns the redirect (in an opaque fashion). Sets request's redirect. */
+  redirect?: string;
+  fetcher?: Fetcher | null;
+  cf?: CfType;
+  /** An AbortSignal to set request's signal. */
+  signal?: AbortSignal | null;
+}
+declare abstract class Fetcher {
+  fetch(
+    input: RequestInfo,
+    init?: RequestInit<RequestInitCfProperties>
+  ): Promise<Response>;
+  connect(address: string, options?: SocketOptions): Socket;
+}
+declare interface FetcherPutOptions {
+  expiration?: number;
+  expirationTtl?: number;
+}
+declare interface KVNamespaceListKey<Metadata, Key extends string = string> {
+  name: Key;
+  expiration?: number;
+  metadata?: Metadata;
+}
+declare type KVNamespaceListResult<Metadata, Key extends string = string> =
+  | {
+      list_complete: false;
+      keys: KVNamespaceListKey<Metadata, Key>[];
+      cursor: string;
+    }
+  | {
+      list_complete: true;
+      keys: KVNamespaceListKey<Metadata, Key>[];
+    };
+declare interface KVNamespace<Key extends string = string> {
   get(
-    key: K,
+    key: Key,
     options?: Partial<KVNamespaceGetOptions<undefined>>
   ): Promise<string | null>;
-  get(key: K, type: "text"): Promise<string | null>;
+  get(key: Key, type: "text"): Promise<string | null>;
   get<ExpectedValue = unknown>(
-    key: K,
+    key: Key,
     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(key: Key, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
+  get(key: Key, type: "stream"): Promise<ReadableStream | null>;
+  get(
+    key: Key,
+    options?: KVNamespaceGetOptions<"text">
+  ): Promise<string | null>;
   get<ExpectedValue = unknown>(
-    key: string,
-    options: KVNamespaceGetOptions<"json">
+    key: Key,
+    options?: KVNamespaceGetOptions<"json">
   ): Promise<ExpectedValue | null>;
   get(
-    key: K,
-    options: KVNamespaceGetOptions<"arrayBuffer">
-  ): Promise<ArrayBuffer | null>;
+    key: Key,
+    options?: KVNamespaceGetOptions<"arrayBuffer">
+  ): Promise<string | null>;
   get(
-    key: K,
-    options: KVNamespaceGetOptions<"stream">
-  ): Promise<ReadableStream | null>;
+    key: Key,
+    options?: KVNamespaceGetOptions<"stream">
+  ): Promise<string | 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);
-   */
+  ): Promise<KVNamespaceListResult<Metadata, Key>>;
   put(
-    key: K,
+    key: Key,
     value: string | ArrayBuffer | ArrayBufferView | ReadableStream,
     options?: KVNamespacePutOptions
   ): Promise<void>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     options?: Partial<KVNamespaceGetOptions<undefined>>
   ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     type: "text"
   ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
-    key: K,
+    key: Key,
     type: "json"
   ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     type: "arrayBuffer"
   ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     type: "stream"
   ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     options: KVNamespaceGetOptions<"text">
   ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
-    key: K,
+    key: Key,
     options: KVNamespaceGetOptions<"json">
   ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     options: KVNamespaceGetOptions<"arrayBuffer">
   ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
   getWithMetadata<Metadata = unknown>(
-    key: K,
+    key: Key,
     options: KVNamespaceGetOptions<"stream">
   ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
-  delete(name: string): Promise<void>;
-}
-
-interface KVNamespaceGetOptions<Type> {
-  type: Type;
-  cacheTtl?: number;
-}
-
-interface KVNamespaceGetWithMetadataResult<Value, Metadata> {
-  value: Value | null;
-  metadata: Metadata | null;
-}
-
-interface KVNamespaceListKey<Metadata> {
-  name: string;
-  expiration?: number;
-  metadata?: Metadata;
+  delete(key: Key): Promise<void>;
 }
-
-interface KVNamespaceListOptions {
+declare interface KVNamespaceListOptions {
   limit?: number;
   prefix?: string | null;
   cursor?: string | null;
 }
-
-interface KVNamespaceListResult<Metadata> {
-  keys: KVNamespaceListKey<Metadata>[];
-  list_complete: boolean;
-  cursor?: string;
+declare interface KVNamespaceGetOptions<Type> {
+  type: Type;
+  cacheTtl?: number;
 }
-
-interface KVNamespacePutOptions {
+declare interface KVNamespacePutOptions {
   expiration?: number;
   expirationTtl?: number;
   metadata?: any | null;
 }
-
-declare class MessageEvent extends Event {
-  constructor(type: string, initializer: MessageEventInit);
-  readonly data: ArrayBuffer | string;
-}
-
-interface MessageEventInit {
-  data: ArrayBuffer | string;
-}
-
-/**
- * Back compat for code migrating from older definitions.
- * @deprecated Use MessageEventInit instead.
- */
-declare type MessageEventInitializer = MessageEventInit;
-
-declare abstract class Navigator {
-  readonly userAgent: string;
-}
-
-/**
- * Transitionary name.
- * @deprecated Use StreamPipeOptions
- */
-interface PipeToOptions {
-  preventClose?: boolean;
-  preventAbort?: boolean;
-  preventCancel?: boolean;
-  signal?: AbortSignal;
-}
-
-declare abstract class PromiseRejectionEvent extends Event {
-  readonly promise: Promise<any>;
-  readonly reason: any;
+declare interface KVNamespaceGetWithMetadataResult<Value, Metadata> {
+  value: Value | null;
+  metadata: Metadata | null;
 }
-
-interface QueuingStrategyInit {
-  highWaterMark: number;
+declare interface R2Error extends Error {
+  readonly name: string;
+  readonly code: number;
+  readonly message: string;
+  readonly action: string;
+  readonly stack: any;
 }
-
-/**
- * An instance of the R2 bucket binding.
- */
-interface R2Bucket {
-  head(key: string): Promise<R2Object | null>;
-  get(key: string): Promise<R2ObjectBody | null>;
-  /**
-   * Returns R2Object on a failure of the conditional specified in onlyIf.
-   */
-  get(
-    key: string,
-    options: R2GetOptions
-  ): Promise<R2ObjectBody | R2Object | null>;
+declare interface R2ListOptions {
+  limit?: number;
+  prefix?: string;
+  cursor?: string;
+  delimiter?: string;
+  startAfter?: string;
+}
+declare abstract class R2Bucket {
+  head(key: string): Promise<R2Object | null>;
   get(
     key: string,
-    options?: R2GetOptions
+    options: R2GetOptions & {
+      onlyIf: R2Conditional | Headers;
+    }
   ): Promise<R2ObjectBody | R2Object | null>;
+  get(key: string, options?: R2GetOptions): Promise<R2ObjectBody | null>;
   put(
     key: string,
     value:
@@ -893,85 +1168,28 @@ interface R2Bucket {
       | Blob,
     options?: R2PutOptions
   ): Promise<R2Object>;
+  createMultipartUpload(
+    key: string,
+    options?: R2MultipartOptions
+  ): Promise<R2MultipartUpload>;
+  resumeMultipartUpload(key: string, uploadId: string): R2MultipartUpload;
   delete(keys: string | string[]): Promise<void>;
   list(options?: R2ListOptions): Promise<R2Objects>;
 }
-
-/**
- * The checksums associated with the object.
- */
-interface R2Checksums {
-  md5?: ArrayBuffer;
-  sha1?: ArrayBuffer;
-  sha256?: ArrayBuffer;
-  sha384?: ArrayBuffer;
-  sha512?: ArrayBuffer;
-}
-
-/**
- * Perform the operation conditionally based on meeting the defined criteria.
- */
-interface R2Conditional {
-  etagMatches?: string;
-  etagDoesNotMatch?: string;
-  uploadedBefore?: Date;
-  uploadedAfter?: Date;
-  secondsGranularity?: boolean;
-}
-
-/**
- * Options for retrieving the object metadata nad payload.
- */
-interface R2GetOptions {
-  onlyIf?: R2Conditional | Headers;
-  range?: R2Range | Headers;
-}
-
-/**
- * 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;
-}
-
-interface R2ListOptions {
-  limit?: number;
-  prefix?: string;
-  cursor?: string;
-  delimiter?: string;
-  startAfter?: 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")[];
+declare interface R2MultipartUpload {
+  readonly key: string;
+  readonly uploadId: string;
+  uploadPart(
+    partNumber: number,
+    value: ReadableStream | (ArrayBuffer | ArrayBufferView) | string | Blob
+  ): Promise<R2UploadedPart>;
+  abort(): Promise<void>;
+  complete(uploadedParts: R2UploadedPart[]): Promise<R2Object>;
+}
+declare interface R2UploadedPart {
+  partNumber: number;
+  etag: string;
 }
-
-/**
- * The metadata for the object.
- */
 declare abstract class R2Object {
   readonly key: string;
   readonly version: string;
@@ -985,27 +1203,38 @@ declare abstract class R2Object {
   readonly range?: R2Range;
   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;
+declare interface R2ObjectBody extends R2Object {
+  get body(): ReadableStream;
+  get 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[];
+declare type R2Range =
+  | {
+      offset: number;
+      length?: number;
+    }
+  | {
+      offset?: number;
+      length: number;
+    }
+  | {
+      suffix: number;
+    };
+declare interface R2Conditional {
+  etagMatches?: string;
+  etagDoesNotMatch?: string;
+  uploadedBefore?: Date;
+  uploadedAfter?: Date;
+  secondsGranularity?: boolean;
 }
-
-interface R2PutOptions {
+declare interface R2GetOptions {
+  onlyIf?: R2Conditional | Headers;
+  range?: R2Range | Headers;
+}
+declare interface R2PutOptions {
   onlyIf?: R2Conditional | Headers;
   httpMetadata?: R2HTTPMetadata | Headers;
   customMetadata?: Record<string, string>;
@@ -1015,464 +1244,316 @@ interface R2PutOptions {
   sha384?: ArrayBuffer | string;
   sha512?: ArrayBuffer | string;
 }
-
-declare type R2Range =
-  | { offset: number; length?: number }
-  | { offset?: number; length: number }
-  | { suffix: number };
-
-interface ReadResult {
-  value?: any;
-  done: boolean;
-}
-
-declare abstract class ReadableByteStreamController {
-  readonly byobRequest: ReadableStreamBYOBRequest | null;
-  readonly desiredSize: number | null;
-  close(): void;
-  enqueue(chunk: ArrayBuffer | ArrayBufferView): void;
-  error(reason: any): void;
-}
-
-declare class ReadableStream {
-  constructor(
-    underlyingSource?: UnderlyingSource,
-    queuingStrategy?: StreamQueuingStrategy
-  );
-  readonly locked: boolean;
-  cancel(reason?: any): Promise<void>;
-  getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
-  getReader(): ReadableStreamDefaultReader;
-  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>>;
-  releaseLock(): void;
-  readAtLeast(
-    minBytes: number,
-    view: Uint8Array
-  ): Promise<ReadableStreamReadResult<Uint8Array>>;
-}
-
-declare abstract class ReadableStreamBYOBRequest {
-  readonly view: Uint8Array | null;
-  respond(bytesWritten: number): void;
-  respondWithNewView(view: ArrayBuffer | ArrayBufferView): void;
-  readonly atLeast: number | null;
-}
-
-declare abstract class ReadableStreamDefaultController {
-  readonly desiredSize: number | null;
-  close(): void;
-  enqueue(chunk?: any): void;
-  error(reason: any): void;
-}
-
-declare class ReadableStreamDefaultReader {
-  constructor(stream: ReadableStream);
-  readonly closed: Promise<void>;
-  cancel(reason?: any): Promise<void>;
-  read(): Promise<ReadableStreamReadResult<any>>;
-  releaseLock(): void;
-}
-
-interface ReadableStreamGetReaderOptions {
-  mode: string;
-}
-
-/**
- * Back-compat alias.
- * @deprecated Use StreamPipeOptions
- */
-declare type ReadableStreamPipeToOptions = PipeToOptions;
-
-declare type ReadableStreamReadResult<T = any> =
-  | { done: true; value: undefined }
-  | { done: false; value: T };
-
-/**
- * Back-compat alias.
- * @deprecated Use ReadableStreamBYOBReader
- */
-declare type ReadableStreamReadableStreamBYOBReader = ReadableStreamBYOBReader;
-
-/**
- * Back-compat alias.
- * @deprecated Use 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;
-  readonly method: string;
-  readonly url: string;
-  readonly headers: Headers;
-  readonly redirect: string;
-  readonly fetcher: Fetcher | null;
-  readonly signal: AbortSignal;
-  /**
-   * In addition to the properties on the standard `Request` object,
-   * the `cf` object contains extra information about the request provided
-   * by Cloudflare's edge.
-   *
-   * Returns undefined when accessed in the playground.
-   */
-  readonly cf?: IncomingRequestCfProperties;
-}
-
-interface RequestInit {
-  method?: string;
-  headers?: HeadersInit;
-  body?: BodyInit | null;
-  redirect?: string;
-  fetcher?: Fetcher | null;
-  /**
-   * 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: { ... } })
-   */
-  cf?: IncomingRequestCfProperties | RequestInitCfProperties;
-  signal?: AbortSignal | null;
-}
-
-/**
- * Back compat for code migrating from older definitions.
- * @deprecated Use RequestInit instead.
- */
-declare type RequestInitializerDict = RequestInit;
-
-declare class Response extends Body {
-  constructor(bodyInit?: BodyInit | null, maybeInit?: ResponseInit | Response);
-  static redirect(url: string, status?: number): Response;
-  static json(any: any, maybeInit?: ResponseInit | Response): Response;
-  clone(): Response;
-  readonly status: number;
-  readonly statusText: string;
-  readonly headers: Headers;
-  readonly ok: boolean;
-  readonly redirected: boolean;
-  readonly url: string;
-  readonly webSocket: WebSocket | null;
-  readonly cf?: Object;
+declare interface R2MultipartOptions {
+  httpMetadata?: R2HTTPMetadata | Headers;
+  customMetadata?: Record<string, string>;
 }
-
-interface ResponseInit {
-  status?: number;
-  statusText?: string;
-  headers?: HeadersInit;
-  cf?: Object;
-  webSocket?: WebSocket | null;
-  encodeBody?: string;
+declare interface R2Checksums {
+  readonly md5?: ArrayBuffer;
+  readonly sha1?: ArrayBuffer;
+  readonly sha256?: ArrayBuffer;
+  readonly sha384?: ArrayBuffer;
+  readonly sha512?: ArrayBuffer;
+  toJSON(): R2StringChecksums;
+}
+declare interface R2StringChecksums {
+  md5?: string;
+  sha1?: string;
+  sha256?: string;
+  sha384?: string;
+  sha512?: string;
+}
+declare interface R2HTTPMetadata {
+  contentType?: string;
+  contentLanguage?: string;
+  contentDisposition?: string;
+  contentEncoding?: string;
+  cacheControl?: string;
+  cacheExpiry?: Date;
 }
-
-/**
- * Back compat for code migrating from older definitions.
- * @deprecated Use ResponseInit instead.
- */
-declare type ResponseInitializerDict = ResponseInit;
-
-interface RsaOtherPrimesInfo {
-  r?: string;
-  d?: string;
-  t?: string;
+declare interface R2Objects {
+  objects: R2Object[];
+  truncated: boolean;
+  cursor?: string;
+  delimitedPrefixes: string[];
 }
-
-interface ScheduledController {
+declare abstract class ScheduledEvent extends ExtendableEvent {
   readonly scheduledTime: number;
   readonly cron: string;
   noRetry(): void;
 }
-
-declare abstract class ScheduledEvent extends ExtendableEvent {
+declare interface ScheduledController {
   readonly scheduledTime: number;
   readonly cron: string;
   noRetry(): void;
 }
-
-interface Scheduler {
-  wait(delay: number, maybeOptions?: SchedulerWaitOptions): Promise<void>;
+declare interface QueuingStrategy<T = any> {
+  highWaterMark?: number | bigint;
+  size?: (chunk: T) => number | bigint;
 }
-
-interface SchedulerWaitOptions {
+declare interface UnderlyingSink<W = any> {
+  type?: string;
+  start?: (controller: WritableStreamDefaultController) => void | Promise<void>;
+  write?: (
+    chunk: W,
+    controller: WritableStreamDefaultController
+  ) => void | Promise<void>;
+  abort?: (reason: any) => void | Promise<void>;
+  close?: () => void | Promise<void>;
+}
+declare interface UnderlyingByteSource {
+  type: "bytes";
+  autoAllocateChunkSize?: number;
+  start?: (controller: ReadableByteStreamController) => void | Promise<void>;
+  pull?: (controller: ReadableByteStreamController) => void | Promise<void>;
+  cancel?: (reason: any) => void | Promise<void>;
+}
+declare interface UnderlyingSource<R = any> {
+  type?: "" | undefined;
+  start?: (
+    controller: ReadableStreamDefaultController<R>
+  ) => void | Promise<void>;
+  pull?: (
+    controller: ReadableStreamDefaultController<R>
+  ) => void | Promise<void>;
+  cancel?: (reason: any) => void | Promise<void>;
+}
+declare interface Transformer<I = any, O = any> {
+  readableType?: string;
+  writableType?: string;
+  start?: (
+    controller: TransformStreamDefaultController<O>
+  ) => void | Promise<void>;
+  transform?: (
+    chunk: I,
+    controller: TransformStreamDefaultController<O>
+  ) => void | Promise<void>;
+  flush?: (
+    controller: TransformStreamDefaultController<O>
+  ) => void | Promise<void>;
+}
+declare interface StreamPipeOptions {
+  /**
+   * 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.
+   *
+   * Piping a stream will lock it for the duration of the pipe, preventing any other consumer from acquiring a reader.
+   *
+   * Errors and closures of the source and destination streams propagate as follows:
+   *
+   * An error in this source readable stream will abort destination, unless preventAbort is truthy. The returned promise will be rejected with the source's error, or with any error that occurs during aborting the destination.
+   *
+   * An error in destination will cancel this source readable stream, unless preventCancel is truthy. The returned promise will be rejected with the destination's error, or with any error that occurs during canceling the source.
+   *
+   * When this source readable stream closes, destination will be closed, unless preventClose is truthy. The returned promise will be fulfilled once this process completes, unless an error is encountered while closing the destination, in which case it will be rejected with that error.
+   *
+   * If destination starts out closed or closing, this source readable stream will be canceled, unless preventCancel is true. The returned promise will be rejected with an error indicating piping to a closed stream failed, or with any error that occurs during canceling the source.
+   *
+   * 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;
 }
-
-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;
-  clearTimeout(timeoutId: number | null): void;
-  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>;
-  self: ServiceWorkerGlobalScope;
-  crypto: Crypto;
-  caches: CacheStorage;
-  scheduler: Scheduler;
-  navigator: Navigator;
-  readonly console: Console;
-  origin: void;
+declare type ReadableStreamReadResult<R = any> =
+  | {
+      done: false;
+      value: R;
+    }
+  | {
+      done: true;
+      value?: undefined;
+    };
+/** This Streams API interface represents a readable stream of byte data. The Fetch API offers a concrete instance of a ReadableStream through the body property of a Response object. */
+declare interface ReadableStream<R = any> {
+  readonly locked: boolean;
+  cancel(reason?: any): Promise<void>;
+  getReader(): ReadableStreamDefaultReader<R>;
+  getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
+  pipeThrough<T>(
+    transform: ReadableWritablePair<T, R>,
+    options?: StreamPipeOptions
+  ): ReadableStream<T>;
+  pipeTo(
+    destination: WritableStream<R>,
+    options?: StreamPipeOptions
+  ): Promise<void>;
+  tee(): [ReadableStream<R>, ReadableStream<R>];
+  values(options?: ReadableStreamValuesOptions): AsyncIterableIterator<R>;
+  [Symbol.asyncIterator](
+    options?: ReadableStreamValuesOptions
+  ): AsyncIterableIterator<R>;
+}
+declare const ReadableStream: {
+  prototype: ReadableStream;
+  new (
+    underlyingSource: UnderlyingByteSource,
+    strategy?: QueuingStrategy<Uint8Array>
+  ): ReadableStream<Uint8Array>;
+  new <R = any>(
+    underlyingSource?: UnderlyingSource<R>,
+    strategy?: QueuingStrategy<R>
+  ): ReadableStream<R>;
+};
+declare class ReadableStreamDefaultReader<R = any> {
+  constructor(stream: ReadableStream);
+  readonly closed: Promise<void>;
+  cancel(reason?: any): Promise<void>;
+  read(): Promise<ReadableStreamReadResult<R>>;
+  releaseLock(): void;
 }
-
-interface ServiceWorkerGlobalScopeStructuredCloneOptions {
-  transfer?: 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>>;
+  releaseLock(): void;
+  readAtLeast<T extends ArrayBufferView>(
+    minElements: number,
+    view: T
+  ): Promise<ReadableStreamReadResult<T>>;
 }
-
-declare type StreamPipeOptions = PipeToOptions;
-
-interface StreamQueuingStrategy {
-  highWaterMark?: bigint;
-  size(chunk: any): number;
+declare interface ReadableStreamGetReaderOptions {
+  mode: "byob";
 }
-
-declare abstract class SubtleCrypto {
-  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 | ArrayBufferView,
-    unwrappingKey: CryptoKey,
-    unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm,
-    unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm,
-    extractable: boolean,
-    keyUsages: string[]
-  ): Promise<CryptoKey>;
-  timingSafeEqual(
-    a: ArrayBuffer | ArrayBufferView,
-    b: ArrayBuffer | ArrayBufferView
-  ): boolean;
+declare interface ReadableStreamBYOBRequest {
+  readonly view: Uint8Array | null;
+  respond(bytesWritten: number): void;
+  respondWithNewView(view: ArrayBuffer | ArrayBufferView): void;
+  readonly atLeast: number | null;
 }
-
-interface SubtleCryptoDeriveKeyAlgorithm {
-  name: string;
-  salt?: ArrayBuffer;
-  iterations?: number;
-  hash?: string | SubtleCryptoHashAlgorithm;
-  public?: CryptoKey;
-  info?: ArrayBuffer;
+declare interface ReadableStreamDefaultController<R = any> {
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk?: R): void;
+  error(reason: any): void;
 }
-
-interface SubtleCryptoEncryptAlgorithm {
-  name: string;
-  iv?: ArrayBuffer;
-  additionalData?: ArrayBuffer;
-  tagLength?: number;
-  counter?: ArrayBuffer;
-  length?: number;
-  label?: ArrayBuffer;
+declare interface ReadableByteStreamController {
+  readonly byobRequest: ReadableStreamBYOBRequest | null;
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk: ArrayBuffer | ArrayBufferView): void;
+  error(reason: any): void;
 }
-
-interface SubtleCryptoGenerateKeyAlgorithm {
-  name: string;
-  hash?: string | SubtleCryptoHashAlgorithm;
-  modulusLength?: number;
-  publicExponent?: ArrayBuffer;
-  length?: number;
-  namedCurve?: string;
+/** This Streams API interface represents a controller allowing control of a WritableStream's state. When constructing a WritableStream, the underlying sink is given a corresponding WritableStreamDefaultController instance to manipulate. */
+declare interface WritableStreamDefaultController {
+  readonly signal: AbortSignal;
+  error(reason?: any): void;
 }
-
-interface SubtleCryptoHashAlgorithm {
-  name: string;
+declare interface TransformStreamDefaultController<O = any> {
+  get desiredSize(): number | null;
+  enqueue(chunk?: O): void;
+  error(reason: any): void;
+  terminate(): void;
 }
-
-interface SubtleCryptoImportKeyAlgorithm {
-  name: string;
-  hash?: string | SubtleCryptoHashAlgorithm;
-  length?: number;
-  namedCurve?: string;
-  compressed?: boolean;
+declare interface ReadableWritablePair<R = any, W = any> {
+  /**
+   * 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>;
 }
-
-/**
- *
- * @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;
-
-interface SubtleCryptoSignAlgorithm {
-  name: string;
-  hash?: string | SubtleCryptoHashAlgorithm;
-  dataLength?: number;
-  saltLength?: number;
+declare class WritableStream<W = any> {
+  constructor(
+    underlyingSink?: UnderlyingSink,
+    queuingStrategy?: QueuingStrategy
+  );
+  readonly locked: boolean;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  getWriter(): WritableStreamDefaultWriter<W>;
 }
-
-interface Text {
-  readonly text: string;
-  readonly lastInTextNode: boolean;
-  readonly removed: boolean;
-  before(content: Content, options?: ContentOptions): Text;
-  after(content: Content, options?: ContentOptions): Text;
-  replace(content: Content, options?: ContentOptions): Text;
-  remove(): Text;
+declare class WritableStreamDefaultWriter<W = any> {
+  constructor(stream: WritableStream);
+  readonly closed: Promise<void>;
+  readonly ready: Promise<void>;
+  readonly desiredSize: number | null;
+  abort(reason?: any): Promise<void>;
+  close(): Promise<void>;
+  write(chunk?: W): Promise<void>;
+  releaseLock(): void;
 }
-
-declare class TextDecoder {
+declare class TransformStream<I = any, O = any> {
   constructor(
-    label?: "utf-8" | "utf8" | "unicode-1-1-utf-8",
-    options?: TextDecoderConstructorOptions
+    transformer?: Transformer<I, O>,
+    writableStrategy?: QueuingStrategy<I>,
+    readableStrategy?: QueuingStrategy<O>
   );
-  decode(
-    input?: ArrayBuffer | ArrayBufferView,
-    options?: TextDecoderDecodeOptions
-  ): string;
-  readonly encoding: string;
-  readonly fatal: boolean;
-  readonly ignoreBOM: boolean;
+  readonly readable: ReadableStream<O>;
+  readonly writable: WritableStream<I>;
 }
-
-interface TextDecoderConstructorOptions {
-  fatal: boolean;
-  ignoreBOM: boolean;
+declare class FixedLengthStream extends IdentityTransformStream {
+  constructor(expectedLength: number | bigint);
 }
-
-interface TextDecoderDecodeOptions {
-  stream: boolean;
+declare class IdentityTransformStream extends TransformStream<
+  ArrayBuffer | ArrayBufferView,
+  Uint8Array
+> {
+  constructor();
 }
-
-declare class TextDecoderStream extends TransformStream {
+declare interface ReadableStreamValuesOptions {
+  preventCancel?: boolean;
+}
+declare class CompressionStream extends TransformStream<
+  ArrayBuffer | ArrayBufferView,
+  Uint8Array
+> {
+  constructor(format: "gzip" | "deflate");
+}
+declare class DecompressionStream extends TransformStream<
+  ArrayBuffer | ArrayBufferView,
+  Uint8Array
+> {
+  constructor(format: "gzip" | "deflate");
+}
+declare class TextEncoderStream extends TransformStream<string, Uint8Array> {
+  constructor();
+}
+declare class TextDecoderStream extends TransformStream<
+  ArrayBuffer | ArrayBufferView,
+  string
+> {
   constructor(label?: string, options?: TextDecoderStreamTextDecoderStreamInit);
 }
-
-interface TextDecoderStreamTextDecoderStreamInit {
+declare interface TextDecoderStreamTextDecoderStreamInit {
   fatal?: boolean;
 }
-
-declare class TextEncoder {
-  constructor();
-  encode(input?: string): Uint8Array;
-  encodeInto(input: string, buffer: Uint8Array): TextEncoderEncodeIntoResult;
-  readonly encoding: string;
+declare class ByteLengthQueuingStrategy
+  implements QueuingStrategy<ArrayBufferView>
+{
+  constructor(init: QueuingStrategyInit);
+  get highWaterMark(): number;
+  get size(): (chunk?: any) => number;
 }
-
-interface TextEncoderEncodeIntoResult {
-  read: number;
-  written: number;
+declare class CountQueuingStrategy implements QueuingStrategy {
+  constructor(init: QueuingStrategyInit);
+  get highWaterMark(): number;
+  get size(): (chunk?: any) => number;
 }
-
-declare class TextEncoderStream extends TransformStream {
-  constructor();
+declare interface QueuingStrategyInit {
+  /**
+   * Creates a new ByteLengthQueuingStrategy with the provided high water mark.
+   *
+   * Note that the provided high water mark will not be validated ahead of time. Instead, if it is negative, NaN, or not a number, the resulting ByteLengthQueuingStrategy will cause the corresponding stream constructor to throw.
+   */
+  highWaterMark: number;
 }
-
-interface TraceEvent extends ExtendableEvent {
+declare abstract class TraceEvent extends ExtendableEvent {
   readonly traces: TraceItem[];
 }
-
-interface TraceException {
-  readonly timestamp: number;
-  readonly message: string;
-  readonly name: string;
-}
-
-interface TraceItem {
-  readonly event: TraceItemEventInfo | null;
+declare interface TraceItem {
+  readonly event:
+    | (
+        | TraceItemFetchEventInfo
+        | TraceItemScheduledEventInfo
+        | TraceItemAlarmEventInfo
+        | TraceItemCustomEventInfo
+      )
+    | null;
   readonly eventTimestamp: number | null;
   readonly logs: TraceLog[];
   readonly exceptions: TraceException[];
@@ -1480,76 +1561,47 @@ interface TraceItem {
   readonly dispatchNamespace?: string;
   readonly outcome: string;
 }
-
-interface TraceItemAlarmEventInfo {
+declare interface TraceItemAlarmEventInfo {
   readonly scheduledTime: Date;
 }
-
-declare type TraceItemEventInfo =
-  | TraceItemFetchEventInfo
-  | TraceItemScheduledEventInfo
-  | TraceItemAlarmEventInfo;
-
-interface TraceItemFetchEventInfo {
+declare interface TraceItemCustomEventInfo {}
+declare interface TraceItemScheduledEventInfo {
+  readonly scheduledTime: number;
+  readonly cron: string;
+}
+declare interface TraceItemFetchEventInfo {
   readonly response?: TraceItemFetchEventInfoResponse;
   readonly request: TraceItemFetchEventInfoRequest;
 }
-
-interface TraceItemFetchEventInfoRequest {
-  readonly cf?: Object;
+declare interface TraceItemFetchEventInfoRequest {
+  readonly cf?: any;
   readonly headers: Record<string, string>;
   readonly method: string;
   readonly url: string;
   getUnredacted(): TraceItemFetchEventInfoRequest;
 }
-
-interface TraceItemFetchEventInfoResponse {
+declare interface TraceItemFetchEventInfoResponse {
   readonly status: number;
 }
-
-interface TraceItemScheduledEventInfo {
-  readonly scheduledTime: number;
-  readonly cron: string;
-}
-
-interface TraceLog {
+declare interface TraceLog {
   readonly timestamp: number;
   readonly level: string;
-  readonly message: Object;
+  readonly message: any;
 }
-
-interface TraceMetrics {
+declare interface TraceException {
+  readonly timestamp: number;
+  readonly message: string;
+  readonly name: string;
+}
+declare interface TraceMetrics {
   readonly cpuTime: number;
   readonly wallTime: number;
 }
-
-declare class TransformStream {
-  constructor(
-    maybeTransformer?: Transformer,
-    maybeWritableStrategy?: StreamQueuingStrategy,
-    maybeReadableStrategy?: StreamQueuingStrategy
-  );
-  readonly readable: ReadableStream;
-  readonly writable: WritableStream;
-}
-
-interface TransformStreamDefaultController {
-  readonly desiredSize: number | null;
-  enqueue(chunk: any): void;
-  error(reason: any): void;
-  terminate(): void;
-}
-
-interface Transformer {
-  readableType?: string;
-  writableType?: string;
-  start?(controller: TransformStreamDefaultController): any;
-  transform?(chunk: any, controller: TransformStreamDefaultController): any;
-  flush?(controller: TransformStreamDefaultController): any;
+declare interface UnsafeTraceMetrics {
+  fromTrace(item: TraceItem): TraceMetrics;
 }
-
 declare class URL {
-  constructor(url: string, base?: string);
+  constructor(url: string | URL, base?: string | URL);
   href: string;
   readonly origin: string;
   protocol: string;
@@ -1563,32 +1615,55 @@ declare class URL {
   readonly searchParams: URLSearchParams;
   hash: string;
   toString(): string;
-  toJSON(): string;
+  toJSON(): string;
+}
+declare class URLSearchParams {
+  constructor(
+    init?:
+      | URLSearchParams
+      | string
+      | Record<string, string>
+      | [key: string, value: string][]
+  );
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  get(name: string): string | null;
+  getAll(name: string): string[];
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  sort(): void;
+  entries(): IterableIterator<[key: string, value: string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  forEach<This = unknown>(
+    callback: (
+      this: This,
+      value: string,
+      key: string,
+      parent: URLSearchParams
+    ) => void,
+    thisArg?: This
+  ): void;
+  toString(): string;
+  [Symbol.iterator](): IterableIterator<[key: string, value: 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;
+  get protocol(): string;
+  get username(): string;
+  get password(): string;
+  get hostname(): string;
+  get port(): string;
+  get pathname(): string;
+  get search(): string;
+  get 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 {
+declare interface URLPatternURLPatternInit {
   protocol?: string;
   username?: string;
   password?: string;
@@ -1599,8 +1674,11 @@ interface URLPatternURLPatternInit {
   hash?: string;
   baseURL?: string;
 }
-
-interface URLPatternURLPatternResult {
+declare interface URLPatternURLPatternComponentResult {
+  input: string;
+  groups: Record<string, string>;
+}
+declare interface URLPatternURLPatternResult {
   inputs: (string | URLPatternURLPatternInit)[];
   protocol: URLPatternURLPatternComponentResult;
   username: URLPatternURLPatternComponentResult;
@@ -1611,203 +1689,75 @@ interface URLPatternURLPatternResult {
   search: URLPatternURLPatternComponentResult;
   hash: URLPatternURLPatternComponentResult;
 }
-
-declare class URLSearchParams {
-  constructor(init?: URLSearchParamsInit);
-  append(name: string, value: string): void;
-  delete(name: string): void;
-  get(name: string): string | null;
-  getAll(name: string): string[];
-  has(name: string): boolean;
-  set(name: string, value: string): void;
-  sort(): void;
-  entries(): IterableIterator<[key: string, value: string]>;
-  keys(): IterableIterator<string>;
-  values(): IterableIterator<string>;
-  forEach<This = unknown>(
-    callback: (
-      this: This,
-      value: string,
-      key: string,
-      parent: URLSearchParams
-    ) => void,
-    thisArg?: This
-  ): void;
-  [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
-  toString(): string;
+declare class CloseEvent extends Event {
+  constructor(type: string, initializer: CloseEventInit);
+  /** Returns the WebSocket connection close code provided by the server. */
+  readonly code: number;
+  /** Returns the WebSocket connection close reason provided by the server. */
+  readonly reason: string;
+  /** Returns true if the connection closed cleanly; false otherwise. */
+  readonly wasClean: boolean;
 }
-
-declare type URLSearchParamsInit =
-  | URLSearchParams
-  | string
-  | Record<string, string>
-  | [key: string, value: string][];
-
-/**
- * Back compat for code migrating to older definitions.
- * This technically isn't part of a standard either way, but the naming
- * is more consistent.
- * @deprecated Use URLSearchParamsInit instead.
- */
-declare type URLSearchParamsInitializer = URLSearchParamsInit;
-
-interface UnderlyingSink {
-  type?: string;
-  start?(controller: WritableStreamDefaultController): any;
-  write?(chunk: any, controller: WritableStreamDefaultController): any;
-  abort?(reason: any): any;
-  close?(): any;
+declare interface CloseEventInit {
+  code?: number;
+  reason?: string;
+  wasClean?: boolean;
 }
-
-interface UnderlyingSource {
-  type?: string;
-  autoAllocateChunkSize?: number;
-  start?(
-    controller: ReadableStreamDefaultController | ReadableByteStreamController
-  ): any;
-  pull?(
-    controller: ReadableStreamDefaultController | ReadableByteStreamController
-  ): any;
-  cancel?(reason?: any): any;
+declare class MessageEvent extends Event {
+  constructor(type: string, initializer: MessageEventInit);
+  readonly data: ArrayBuffer | string;
 }
-
-interface UnsafeTraceMetrics {
-  fromTrace(arg4: TraceItem): TraceMetrics;
+declare interface MessageEventInit {
+  data: ArrayBuffer | string;
 }
-
+/** Events providing information related to errors in scripts or in files. */
+declare interface ErrorEvent extends Event {
+  readonly filename: string;
+  readonly message: string;
+  readonly lineno: number;
+  readonly colno: number;
+  readonly error: any;
+}
+declare type WebSocketEventMap = {
+  close: CloseEvent;
+  message: MessageEvent;
+  open: Event;
+  error: ErrorEvent;
+};
 declare class WebSocket extends EventTarget<WebSocketEventMap> {
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
-  send(message: ArrayBuffer | ArrayBufferView | string): void;
+  send(message: (ArrayBuffer | ArrayBufferView) | string): void;
   close(code?: number, reason?: string): void;
   static readonly READY_STATE_CONNECTING: number;
   static readonly READY_STATE_OPEN: number;
   static readonly READY_STATE_CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
+  /** Returns the state of the WebSocket object's connection. It can have the values described below. */
   readonly readyState: number;
+  /** Returns the URL that was used to establish the WebSocket connection. */
   readonly url: string | null;
+  /** Returns the subprotocol selected by the server, if any. It can be used in conjunction with the array form of the constructor's second argument to perform subprotocol negotiation. */
   readonly protocol: string | null;
+  /** Returns the extensions selected by the server, if any. */
   readonly extensions: string | null;
 }
-
-declare type WebSocketEventMap = {
-  close: CloseEvent;
-  message: MessageEvent;
-  open: Event;
-  error: ErrorEvent;
-};
-
-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 const WebSocketPair: {
+  new (): {
+    0: WebSocket;
+    1: WebSocket;
+  };
 };
-
-declare class WritableStream {
-  constructor(
-    underlyingSink?: UnderlyingSink,
-    queuingStrategy?: StreamQueuingStrategy
-  );
-  readonly locked: boolean;
-  abort(reason: any): Promise<void>;
-  close(): Promise<void>;
-  getWriter(): WritableStreamDefaultWriter;
-}
-
-declare abstract class WritableStreamDefaultController {
-  readonly signal: AbortSignal;
-  error(reason?: any): void;
-}
-
-declare class WritableStreamDefaultWriter {
-  constructor(stream: WritableStream);
+declare interface Socket {
+  readonly readable: ReadableStream;
+  readonly writable: WritableStream;
   readonly closed: Promise<void>;
-  readonly ready: Promise<void>;
-  readonly desiredSize: number | null;
-  abort(reason: any): Promise<void>;
   close(): Promise<void>;
-  write(chunk: any): Promise<void>;
-  releaseLock(): void;
 }
-
-/**
- * Back-compat alias.
- * @deprecated Use WritableStreamDefaultWriter
- */
-declare type WritableStreamWritableStreamDefaultWriter =
-  WritableStreamDefaultWriter;
-
-declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(
-  type: Type,
-  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
-  options?: EventTargetAddEventListenerOptions | boolean
-): void;
-
-declare function atob(data: string): string;
-
-declare function btoa(data: string): string;
-
-declare const caches: CacheStorage;
-
-declare function clearInterval(timeoutId: number | null): void;
-
-declare function clearTimeout(timeoutId: number | null): void;
-
-declare const console: Console;
-
-declare const crypto: Crypto;
-
-declare function dispatchEvent(
-  event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]
-): boolean;
-
-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 const scheduler: Scheduler;
-
-declare const self: ServiceWorkerGlobalScope;
-
-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 structuredClone(
-  value: any,
-  options?: ServiceWorkerGlobalScopeStructuredCloneOptions
-): any;
-
-/*** Injected cf.d.ts ***/
-interface BasicImageTransformations {
+declare interface SocketOptions {
+  tsl: boolean;
+}
+declare interface BasicImageTransformations {
   /**
    * Maximum width in image pixels. The value must be an integer.
    */
@@ -1873,12 +1823,10 @@ interface BasicImageTransformations {
    */
   rotate?: 0 | 90 | 180 | 270 | 360;
 }
-
-interface BasicImageTransformationsGravityCoordinates {
+declare interface BasicImageTransformationsGravityCoordinates {
   x: number;
   y: number;
 }
-
 /**
  * In addition to the properties you can set in the RequestInit dict
  * that you pass as an argument to the Request constructor, you can
@@ -1888,7 +1836,7 @@ interface BasicImageTransformationsGravityCoordinates {
  * Note: Currently, these properties cannot be tested in the
  * playground.
  */
-interface RequestInitCfProperties {
+declare interface RequestInitCfProperties {
   cacheEverything?: boolean;
   /**
    * A request's cache key is what determines if two requests are
@@ -1938,8 +1886,8 @@ interface RequestInitCfProperties {
    */
   resolveOverride?: string;
 }
-
-interface RequestInitCfPropertiesImageDraw extends BasicImageTransformations {
+declare interface RequestInitCfPropertiesImageDraw
+  extends BasicImageTransformations {
   /**
    * Absolute URL of the image file to use for the drawing. It can be any of
    * the supported file formats. For drawing of watermarks or non-rectangular
@@ -1976,8 +1924,8 @@ interface RequestInitCfPropertiesImageDraw extends BasicImageTransformations {
   bottom?: number;
   right?: number;
 }
-
-interface RequestInitCfPropertiesImage extends BasicImageTransformations {
+declare interface RequestInitCfPropertiesImage
+  extends BasicImageTransformations {
   /**
    * Device Pixel Ratio. Default 1. Multiplier for width/height that makes it
    * easier to specify higher-DPI sizes in <img srcset>.
@@ -2059,24 +2007,21 @@ interface RequestInitCfPropertiesImage extends BasicImageTransformations {
    */
   "origin-auth"?: "share-publicly";
 }
-
-interface RequestInitCfPropertiesImageMinify {
+declare interface RequestInitCfPropertiesImageMinify {
   javascript?: boolean;
   css?: boolean;
   html?: boolean;
 }
-
 /**
  * Request metadata provided by Cloudflare's edge.
  */
-type IncomingRequestCfProperties<HostMetadata = unknown> =
+declare type IncomingRequestCfProperties<HostMetadata = unknown> =
   IncomingRequestCfPropertiesBase &
     IncomingRequestCfPropertiesBotManagementEnterprise &
     IncomingRequestCfPropertiesCloudflareForSaaSEnterprise<HostMetadata> &
     IncomingRequestCfPropertiesGeographicInformation &
     IncomingRequestCfPropertiesCloudflareAccessOrApiShield;
-
-interface IncomingRequestCfPropertiesBase {
+declare interface IncomingRequestCfPropertiesBase {
   /**
    * [ASN](https://www.iana.org/assignments/as-numbers/as-numbers.xhtml) of the incoming request.
    *
@@ -2154,8 +2099,7 @@ interface IncomingRequestCfPropertiesBase {
    */
   tlsExportedAuthenticator?: IncomingRequestCfPropertiesExportedAuthenticatorMetadata;
 }
-
-interface IncomingRequestCfPropertiesBotManagementBase {
+declare interface IncomingRequestCfPropertiesBotManagementBase {
   /**
    * Cloudflare’s [level of certainty](https://developers.cloudflare.com/bots/concepts/bot-score/) that a request comes from a bot,
    * represented as an integer percentage between `1` (almost certainly human)
@@ -2179,8 +2123,7 @@ interface IncomingRequestCfPropertiesBotManagementBase {
    */
   staticResource: boolean;
 }
-
-interface IncomingRequestCfPropertiesBotManagement {
+declare interface IncomingRequestCfPropertiesBotManagement {
   /**
    * Results of Cloudflare's Bot Management analysis
    */
@@ -2192,8 +2135,7 @@ interface IncomingRequestCfPropertiesBotManagement {
    */
   clientTrustScore: number;
 }
-
-interface IncomingRequestCfPropertiesBotManagementEnterprise
+declare interface IncomingRequestCfPropertiesBotManagementEnterprise
   extends IncomingRequestCfPropertiesBotManagement {
   /**
    * Results of Cloudflare's Bot Management analysis
@@ -2206,8 +2148,9 @@ interface IncomingRequestCfPropertiesBotManagementEnterprise
     ja3Hash: string;
   };
 }
-
-interface IncomingRequestCfPropertiesCloudflareForSaaSEnterprise<HostMetadata> {
+declare interface IncomingRequestCfPropertiesCloudflareForSaaSEnterprise<
+  HostMetadata
+> {
   /**
    * Custom metadata set per-host in [Cloudflare for SaaS](https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/).
    *
@@ -2216,8 +2159,7 @@ interface IncomingRequestCfPropertiesCloudflareForSaaSEnterprise<HostMetadata> {
    */
   hostMetadata: HostMetadata;
 }
-
-interface IncomingRequestCfPropertiesCloudflareAccessOrApiShield {
+declare interface IncomingRequestCfPropertiesCloudflareAccessOrApiShield {
   /**
    * Information about the client certificate presented to Cloudflare.
    *
@@ -2236,11 +2178,10 @@ interface IncomingRequestCfPropertiesCloudflareAccessOrApiShield {
     | IncomingRequestCfPropertiesTLSClientAuth
     | IncomingRequestCfPropertiesTLSClientAuthPlaceholder;
 }
-
 /**
  * Metadata about the request's TLS handshake
  */
-interface IncomingRequestCfPropertiesExportedAuthenticatorMetadata {
+declare interface IncomingRequestCfPropertiesExportedAuthenticatorMetadata {
   /**
    * The client's [`HELLO` message](https://www.rfc-editor.org/rfc/rfc5246#section-7.4.1.2), encoded in hexadecimal
    *
@@ -2266,14 +2207,11 @@ interface IncomingRequestCfPropertiesExportedAuthenticatorMetadata {
    */
   serverFinished: string;
 }
-
 /**
  * Geographic data about the request's origin.
  */
-type IncomingRequestCfPropertiesGeographicInformation =
-  | {
-      /* No geographic data was found for the incoming request. */
-    }
+declare type IncomingRequestCfPropertiesGeographicInformation =
+  | {}
   | {
       /** The country code `"T1"` is used for requests originating on TOR  */
       country: "T1";
@@ -2352,9 +2290,8 @@ type IncomingRequestCfPropertiesGeographicInformation =
        */
       metroCode?: string;
     };
-
 /** Data about the incoming request's TLS certificate */
-interface IncomingRequestCfPropertiesTLSClientAuth {
+declare interface IncomingRequestCfPropertiesTLSClientAuth {
   /** Always `"1"`, indicating that the certificate was presented */
   certPresented: "1";
   /**
@@ -2446,9 +2383,8 @@ interface IncomingRequestCfPropertiesTLSClientAuth {
    */
   certNotAfter: string;
 }
-
 /** Placeholder values for TLS Client Authorization */
-interface IncomingRequestCfPropertiesTLSClientAuthPlaceholder {
+declare interface IncomingRequestCfPropertiesTLSClientAuthPlaceholder {
   certPresented: "0";
   certVerified: "NONE";
   certRevoked: "0";
@@ -2467,7 +2403,6 @@ interface IncomingRequestCfPropertiesTLSClientAuthPlaceholder {
   certNotBefore: "";
   certNotAfter: "";
 }
-
 /** Possible outcomes of TLS verification */
 declare type CertVerificationStatus =
   /** Authentication succeeded */
@@ -2484,7 +2419,6 @@ declare type CertVerificationStatus =
   | "FAILED:certificate has expired"
   /** Failed for another unspecified reason */
   | "FAILED";
-
 /**
  * An upstream endpoint's response to a TCP `keepalive` message from Cloudflare.
  */
@@ -2495,7 +2429,6 @@ declare type IncomingRequestCfPropertiesEdgeRequestKeepAliveStatus =
   | 3 /** no connection re-use, keepalive accepted and saved */
   | 4 /** connection re-use, refused by the origin server (`TCP FIN`) */
   | 5; /** connection re-use, accepted by the origin server */
-
 /** ISO 3166-1 Alpha-2 codes */
 declare type Iso3166Alpha2Code =
   | "AD"
@@ -2747,39 +2680,62 @@ declare type Iso3166Alpha2Code =
   | "ZA"
   | "ZM"
   | "ZW";
-
 /** The 2-letter continent codes Cloudflare uses */
 declare type ContinentCode = "AF" | "AN" | "AS" | "EU" | "NA" | "OC" | "SA";
-/*** Injected pages.d.ts ***/
-type Params<P extends string = any> = Record<P, string | string[]>;
-
-type EventContext<Env, P extends string, Data> = {
+declare interface D1Result<T = unknown> {
+  results?: T[];
+  success: boolean;
+  error?: string;
+  meta: any;
+}
+declare abstract class D1Database {
+  prepare(query: string): D1PreparedStatement;
+  dump(): Promise<ArrayBuffer>;
+  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+  exec<T = unknown>(query: string): Promise<D1Result<T>>;
+}
+declare abstract class D1PreparedStatement {
+  bind(...values: any[]): D1PreparedStatement;
+  first<T = unknown>(colName?: string): Promise<T>;
+  run<T = unknown>(): Promise<D1Result<T>>;
+  all<T = unknown>(): Promise<D1Result<T>>;
+  raw<T = unknown>(): Promise<T[]>;
+}
+declare type Params<P extends string = any> = Record<P, string | string[]>;
+declare type EventContext<Env, P extends string, Data> = {
   request: Request;
   functionPath: string;
   waitUntil: (promise: Promise<any>) => void;
+  passThroughOnException: () => 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;
 };
-
 declare type PagesFunction<
   Env = unknown,
   Params extends string = any,
   Data extends Record<string, unknown> = Record<string, unknown>
 > = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;
-
-type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
+declare type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
   request: Request;
   functionPath: string;
   waitUntil: (promise: Promise<any>) => void;
+  passThroughOnException: () => 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;
   pluginArgs: PluginArgs;
 };
-
 declare type PagesPluginFunction<
   Env = unknown,
   Params extends string = any,
@@ -2788,7 +2744,51 @@ declare type PagesPluginFunction<
 > = (
   context: EventPluginContext<Env, Params, Data, PluginArgs>
 ) => Response | Promise<Response>;
-
 declare module "assets:*" {
   export const onRequest: PagesFunction;
 }
+/**
+ * A message that is sent to a consumer Worker.
+ */
+declare interface Message<Body = unknown> {
+  /**
+   * A unique, system-generated ID for the message.
+   */
+  readonly id: string;
+  /**
+   * A timestamp when the message was sent.
+   */
+  readonly timestamp: Date;
+  /**
+   * The body of the message.
+   */
+  readonly body: Body;
+}
+/**
+ * A batch of messages that are sent to a consumer Worker.
+ */
+declare interface MessageBatch<Body = unknown> {
+  /**
+   * The name of the Queue that belongs to this batch.
+   */
+  readonly queue: string;
+  /**
+   * An array of messages in the batch. Ordering of messages is not guaranteed.
+   */
+  readonly messages: readonly Message<Body>[];
+  /**
+   * Marks every message to be retried in the next batch.
+   */
+  retryAll(): void;
+}
+/**
+ * A binding that allows a producer to send messages to a Queue.
+ */
+declare interface Queue<Body = any> {
+  /**
+   * Sends a message to the Queue.
+   * @param message The message can be any type supported by the [structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm#supported_types), as long as its size is less than 128 KB.
+   * @returns A promise that resolves when the message is confirmed to be written to disk.
+   */
+  send(message: Body): Promise<void>;
+}