@cloudflare/workers-types 2.2.1 → 3.1.1

package/index.d.ts

@@ -1,26 +1,16 @@
-interface FetchEvent {
-  passThroughOnException: () => void;
+// 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(): void;
 }
 
-interface ScheduledEvent {
-  /**
-   * The type of event. This will always return `"scheduled"`.
-   */
-  type: string;
-  /**
-   * The time the `ScheduledEvent` was scheduled to be executed in 
-   * milliseconds since January 1, 1970, UTC. 
-   * It can be parsed as `new Date(event.scheduledTime)`
-   */
-  scheduledTime: number;
-  /**
-   * Use this method to notify the runtime to wait for asynchronous tasks 
-   * (e.g. logging, analytics to third-party services, streaming and caching). 
-   * The first `event.waitUntil` to fail will be observed and recorded as the 
-   * status in the Cron Trigger Past Events table. Otherwise, it will be 
-   * reported as a Success.
-   */
-  waitUntil(promise: Promise<any>): void;
+declare class AbortSignal extends EventTarget {
+  constructor();
+  static abort(): AbortSignal;
+  readonly aborted: boolean;
 }
 
 interface BasicImageTransformations {
@@ -55,11 +45,11 @@ interface BasicImageTransformations {
    *    effect can be more efficiently achieved with the contain mode and the
    *    CSS object-fit: contain property.
    */
-  fit?: 'scale-down' | 'contain' | 'cover' | 'crop' | 'pad';
+  fit?: "scale-down" | "contain" | "cover" | "crop" | "pad";
   /**
    * When cropping with fit: "cover", this defines the side or point that should
    * be left uncropped. The value is either a string
-   * "left", "right", "top", "bottom" or "center" (the default),
+   * "left", "right", "top", "bottom", "auto", or "center" (the default),
    * or an object {x, y} containing focal point coordinates in the original
    * image expressed as fractions ranging from 0.0 (top or left) to 1.0
    * (bottom or right), 0.5 being the center. {fit: "cover", gravity: "top"} will
@@ -68,7 +58,7 @@ interface BasicImageTransformations {
    * preserve as much as possible around a point at 20% of the height of the
    * source image.
    */
-  gravity?: 'left' | 'right' | 'top' | 'bottom' | 'center' | { x: number; y: number };
+  gravity?: "left" | "right" | "top" | "bottom" | "center" | "auto" | BasicImageTransformationsGravityCoordinates;
   /**
    * Background color to add underneath the image. Applies only to images with
    * transparency (such as PNG). Accepts any CSS color (#RRGGBB, rgba(…),
@@ -82,155 +72,499 @@ interface BasicImageTransformations {
   rotate?: 0 | 90 | 180 | 270 | 360;
 }
 
-interface RequestInitCfProperties {
-  /**
-   * In addition to the properties you can set in the RequestInit dict
-   * that you pass as an argument to the Request constructor, you can
-   * set certain properties of a `cf` object to control how Cloudflare
-   * features are applied to that new Request.
-   *
-   * Note: Currently, these properties cannot be tested in the
-   * playground.
-   */
-  cacheEverything?: boolean;
-  /**
-   * A request's cache key is what determines if two requests are
-   * "the same" for caching purposes. If a request has the same cache key
-   * as some previous request, then we can serve the same cached response for
-   * both. (e.g. 'some-key')
-   *
-   * Only available for Enterprise customers.
-   */
-  cacheKey?: string;
-  /**
-   * Force response to be cached for a given number of seconds. (e.g. 300)
-   */
-  cacheTtl?: number;
-  /**
-   * Force response to be cached for a given number of seconds based on the Origin status code.
-   * (e.g. { '200-299': 86400, '404': 1, '500-599': 0 })
-   */
-  cacheTtlByStatus?: { [key: string]: number };
-  scrapeShield?: boolean;
-  apps?: boolean;
-  image?: BasicImageTransformations & {
-    /**
-     * Device Pixel Ratio. Default 1. Multiplier for width/height that makes it
-     * easier to specify higher-DPI sizes in <img srcset>.
-     */
-    dpr?: number;
-    /**
-     * Quality setting from 1-100 (useful values are in 60-90 range). Lower values
-     * make images look worse, but load faster. The default is 85. It applies only
-     * to JPEG and WebP images. It doesn’t have any effect on PNG.
-     */
-    quality?: number;
-    /**
-     * Output format to generate. It can be:
-     *  - avif: generate images in AVIF format.
-     *  - webp: generate images in Google WebP format. Set quality to 100 to get
-     *    the WebP-lossless format.
-     *  - json: instead of generating an image, outputs information about the
-     *    image, in JSON format. The JSON object will contain image size
-     *    (before and after resizing), source image’s MIME type, file size, etc.
-     */
-    format?: 'avif' | 'webp' | 'json';
-    /**
-     * What EXIF data should be preserved in the output image. Note that EXIF
-     * rotation and embedded color profiles are always applied ("baked in" into
-     * the image), and aren't affected by this option. Note that if the Polish
-     * feature is enabled, all metadata may have been removed already and this
-     * option may have no effect.
-     *  - keep: Preserve most of EXIF metadata, including GPS location if there's
-     *    any.
-     *  - copyright: Only keep the copyright tag, and discard everything else.
-     *    This is the default behavior for JPEG files.
-     *  - none: Discard all invisible EXIF metadata. Currently WebP and PNG
-     *    output formats always discard metadata.
-     */
-    metadata?: 'keep' | 'copyright' | 'none';
-    /**
-     * Overlays are drawn in the order they appear in the array (last array
-     * entry is the topmost layer).
-     */
-    draw?: (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
-       * overlays we recommend using PNG or WebP images.
-       */
-      url: string;
-      /**
-       * Floating-point number between 0 (transparent) and 1 (opaque).
-       * For example, opacity: 0.5 makes overlay semitransparent.
-       */
-      opacity?: number;
-      /**
-       * - If set to true, the overlay image will be tiled to cover the entire
-       *   area. This is useful for stock-photo-like watermarks.
-       * - If set to "x", the overlay image will be tiled horizontally only
-       *   (form a line).
-       * - If set to "y", the overlay image will be tiled vertically only
-       *   (form a line).
-       */
-      repeat?: true | 'x' | 'y';
-      /**
-       * Position of the overlay image relative to a given edge. Each property is
-       * an offset in pixels. 0 aligns exactly to the edge. For example, left: 10
-       * positions left side of the overlay 10 pixels from the left edge of the
-       * image it's drawn over. bottom: 0 aligns bottom of the overlay with bottom
-       * of the background image.
-       *
-       * Setting both left & right, or both top & bottom is an error.
-       *
-       * If no position is specified, the image will be centered.
-       */
-      top?: number;
-      left?: number;
-      bottom?: number;
-      right?: number;
-    })[];
-  };
-  minify?: {
-    javascript?: boolean;
-    css?: boolean;
-    html?: boolean;
-  };
-  mirage?: boolean;
-  /**
-   * Redirects the request to an alternate origin server. You can use this,
-   * for example, to implement load balancing across several origins.
-   * (e.g.us-east.example.com)
-   *
-   * Note - For security reasons, the hostname set in resolveOverride must
-   * be proxied on the same Cloudflare zone of the incoming request.
-   * Otherwise, the setting is ignored. CNAME hosts are allowed, so to
-   * resolve to a host under a different domain or a DNS only domain first
-   * declare a CNAME record within your own zone’s DNS mapping to the
-   * external hostname, set proxy on Cloudflare, then set resolveOverride
-   * to point to that CNAME record.
-   */
-  resolveOverride?: string;
+interface BasicImageTransformationsGravityCoordinates {
+  x: number;
+  y: number;
+}
+
+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 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;
+}
+
+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 abstract class Crypto {
+  readonly subtle: SubtleCrypto;
+  getRandomValues<T extends Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array>(buffer: T): T;
+  randomUUID(): string;
+}
+
+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 | CryptoKeyVoprfKeyAlgorithm | CryptoKeyOprfKeyAlgorithm;
+
+interface CryptoKeyEllipticKeyAlgorithm {
+  name: string;
+  namedCurve: string;
+}
+
+interface CryptoKeyHmacKeyAlgorithm {
+  name: string;
+  hash: CryptoKeyKeyAlgorithm;
+  length: number;
+}
+
+interface CryptoKeyKeyAlgorithm {
+  name: string;
+}
+
+interface CryptoKeyOprfKeyAlgorithm {
+  name: string;
+  namedCurve: string;
+}
+
+interface CryptoKeyPair {
+  publicKey: CryptoKey;
+  privateKey: CryptoKey;
+}
+
+interface CryptoKeyRsaKeyAlgorithm {
+  name: string;
+  modulusLength: number;
+  publicExponent: ArrayBuffer;
+  hash?: CryptoKeyKeyAlgorithm;
+}
+
+interface CryptoKeyVoprfKeyAlgorithm {
+  name: string;
+  hash: CryptoKeyKeyAlgorithm;
+  namedCurve: string;
+}
+
+declare class DOMException extends Error {
+  constructor(message?: string, name?: string);
+  readonly code: number;
+  static readonly INDEX_SIZE_ERR: number;
+  static readonly DOMSTRING_SIZE_ERR: number;
+  static readonly HIERARCHY_REQUEST_ERR: number;
+  static readonly WRONG_DOCUMENT_ERR: number;
+  static readonly INVALID_CHARACTER_ERR: number;
+  static readonly NO_DATA_ALLOWED_ERR: number;
+  static readonly NO_MODIFICATION_ALLOWED_ERR: number;
+  static readonly NOT_FOUND_ERR: number;
+  static readonly NOT_SUPPORTED_ERR: number;
+  static readonly INUSE_ATTRIBUTE_ERR: number;
+  static readonly INVALID_STATE_ERR: number;
+  static readonly SYNTAX_ERR: number;
+  static readonly INVALID_MODIFICATION_ERR: number;
+  static readonly NAMESPACE_ERR: number;
+  static readonly INVALID_ACCESS_ERR: number;
+  static readonly VALIDATION_ERR: number;
+  static readonly TYPE_MISMATCH_ERR: number;
+  static readonly SECURITY_ERR: number;
+  static readonly NETWORK_ERR: number;
+  static readonly ABORT_ERR: number;
+  static readonly URL_MISMATCH_ERR: number;
+  static readonly QUOTA_EXCEEDED_ERR: number;
+  static readonly TIMEOUT_ERR: number;
+  static readonly INVALID_NODE_TYPE_ERR: number;
+  static readonly DATA_CLONE_ERR: number;
+}
+
+interface Doctype {
+  readonly name: string | null;
+  readonly publicId: string | null;
+  readonly systemId: string | null;
+}
+
+interface DocumentEnd {
+  append(content: Content, options?: ContentOptions): DocumentEnd;
+}
+
+interface DurableObject {
+  fetch(request: Request): Promise<Response>;
+}
+
+interface DurableObjectGetOptions {
+  allowConcurrency?: boolean;
+  noCache?: boolean;
+}
+
+interface DurableObjectId {
+  toString(): string;
+  equals(other: DurableObjectId): boolean;
+  readonly name?: string;
+}
+
+interface DurableObjectListOptions {
+  start?: string;
+  end?: string;
+  prefix?: string;
+  reverse?: boolean;
+  limit?: number;
+  allowConcurrency?: boolean;
+  noCache?: boolean;
+}
+
+interface DurableObjectNamespace {
+  newUniqueId(options?: DurableObjectNamespaceNewUniqueIdOptions): DurableObjectId;
+  idFromName(name: string): DurableObjectId;
+  idFromString(id: string): DurableObjectId;
+  get(id: DurableObjectId): DurableObjectStub;
+}
+
+interface DurableObjectNamespaceNewUniqueIdOptions {
+  jurisdiction?: string;
+}
+
+interface DurableObjectPutOptions {
+  allowConcurrency?: boolean;
+  allowUnconfirmed?: boolean;
+  noCache?: boolean;
+}
+
+interface DurableObjectState {
+  waitUntil(promise: Promise<any>): void;
+  readonly id: DurableObjectId | string;
+  readonly storage: DurableObjectStorage;
+  blockConcurrencyWhile<T>(callback: () => Promise<T>): Promise<T>;
+}
+
+interface DurableObjectStorage {
+  get<T = unknown>(key: string, options?: DurableObjectGetOptions): Promise<T | undefined>;
+  get<T = unknown>(keys: string[], options?: DurableObjectGetOptions): Promise<Map<string, T>>;
+  list<T = unknown>(options?: DurableObjectListOptions): Promise<Map<string, T>>;
+  put<T>(key: string, value: T, options?: DurableObjectPutOptions): Promise<void>;
+  put<T>(entries: Record<string, T>, options?: DurableObjectPutOptions): Promise<void>;
+  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>;
+}
+
+/**
+ * 
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ */
+declare type DurableObjectStorageOperationsGetOptions = DurableObjectGetOptions;
+
+/**
+ * 
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ */
+declare type DurableObjectStorageOperationsListOptions = DurableObjectListOptions;
+
+/**
+ * 
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ */
+declare type DurableObjectStorageOperationsPutOptions = DurableObjectPutOptions;
+
+interface DurableObjectStub extends Fetcher {
+  readonly id: DurableObjectId;
+  readonly name?: string;
+}
+
+interface DurableObjectTransaction {
+  get<T = unknown>(key: string, options?: DurableObjectGetOptions): Promise<T>;
+  get<T = unknown>(keys: string[], options?: DurableObjectGetOptions): Promise<Map<string, T>>;
+  list<T = unknown>(options?: DurableObjectListOptions): Promise<Map<string, T>>;
+  put<T>(key: string, value: T, options?: DurableObjectPutOptions): Promise<void>;
+  put<T>(entries: Record<string, T>, options?: DurableObjectPutOptions): Promise<void>;
+  delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
+  delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
+  rollback(): 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;
+}
+
+declare class Event {
+  constructor(type: string, init?: EventInit);
+  readonly type: string;
+  readonly eventPhase: number;
+  readonly composed: boolean;
+  readonly bubbles: boolean;
+  readonly cancelable: boolean;
+  readonly defaultPrevented: boolean;
+  readonly returnValue: boolean;
+  readonly currentTarget?: EventTarget;
+  readonly srcElement?: EventTarget;
+  readonly timeStamp: number;
+  readonly isTrusted: boolean;
+  cancelBubble: boolean;
+  stopImmediatePropagation(): void;
+  preventDefault(): void;
+  stopPropagation(): void;
+  composedPath(): EventTarget[];
+  static readonly NONE: number;
+  static readonly CAPTURING_PHASE: number;
+  static readonly AT_TARGET: number;
+  static readonly BUBBLING_PHASE: number;
+}
+
+interface EventInit {
+  bubbles?: boolean;
+  cancelable?: boolean;
+  composed?: boolean;
+}
+
+declare type EventListener<EventType extends Event = Event> = (event: EventType) => void;
+
+interface EventListenerObject<EventType extends Event = Event> {
+  handleEvent(event: EventType): void;
+}
+
+declare type EventListenerOrEventListenerObject<EventType extends Event = Event> = EventListener<EventType> | EventListenerObject<EventType>;
+
+declare class EventTarget<EventMap extends Record<string, Event> = Record<string, Event>> {
+  constructor();
+  addEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetAddEventListenerOptions | boolean): void;
+  removeEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
+  dispatchEvent(event: EventMap[keyof EventMap]): boolean;
+}
+
+interface EventTargetAddEventListenerOptions {
+  capture?: boolean;
+  passive?: boolean;
+  once?: boolean;
+  signal?: AbortSignal;
+}
+
+interface EventTargetEventListenerOptions {
+  capture?: boolean;
+}
+
+interface ExecutionContext {
+  waitUntil(promise: Promise<any>): void;
+  passThroughOnException(): void;
+}
+
+interface ExportedHandler<Env = unknown> {
+  fetch?: ExportedHandlerFetchHandler<Env>;
+  scheduled?: ExportedHandlerScheduledHandler<Env>;
 }
 
+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 abstract class FetchEvent extends Event {
+  readonly request: Request;
+  respondWith(promise: Response | Promise<Response>): void;
+  passThroughOnException(): void;
+  waitUntil(promise: Promise<any>): void;
+}
+
+declare abstract class Fetcher {
+  fetch(requestOrUrl: Request | string, requestInit?: RequestInit | Request): Promise<Response>;
+}
+
+declare class File extends Blob {
+  constructor(bits?: BlobBits, name?: string, options?: FileOptions);
+  readonly name: string;
+  readonly lastModified: number;
+}
+
+interface FileOptions {
+  type?: string;
+  lastModified?: number;
+}
+
+declare class FixedLengthStream extends TransformStream {
+  constructor(expectedLength: 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)[];
+  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])[]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<File | string>;
+  forEach<This = unknown>(callback: (this: This, key: string, value: File | string, parent: FormData) => void, thisArg?: This): void;
+  [Symbol.iterator](): IterableIterator<([key: string, value: File | string])[]>;
+}
+
+declare class HTMLRewriter {
+  constructor();
+  on(selector: string, handlers: HTMLRewriterElementContentHandlers): HTMLRewriter;
+  onDocument(handlers: HTMLRewriterDocumentContentHandlers): HTMLRewriter;
+  transform(response: Response): Response;
+}
+
+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 class Headers {
+  constructor(init?: HeadersInit);
+  get(name: string): string | null;
+  getAll(name: string): string[];
+  has(name: string): boolean;
+  set(name: string, value: string): void;
+  append(name: string, value: string): void;
+  delete(name: string): void;
+  forEach<This = unknown>(callback: (this: This, key: string, value: string, parent: Headers) => void, thisArg?: This): void;
+  entries(): IterableIterator<[key: string, value: string]>;
+  keys(): IterableIterator<string>;
+  values(): IterableIterator<string>;
+  [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
+}
+
+declare type HeadersInit = Headers | Record<string, string> | ([key: string, value: string])[];
+
+/**
+ * Back compat for code migrating to older definitions.
+ * @deprecated Use HeadersInit instead.
+ */
+declare type HeadersInitializer = HeadersInit;
+
+/**
+ * In addition to the properties on the standard Request object,
+ * the cf object contains extra information about the request provided
+ * by Cloudflare's edge.
+ * 
+ * Note: Currently, settings in the cf object cannot be accessed in the
+ * playground.
+ */
 interface IncomingRequestCfProperties {
   /**
-   * In addition to the properties on the standard Request object,
-   * the cf object contains extra information about the request provided
-   * by Cloudflare's edge.
-   *
-   * Note: Currently, settings in the cf object cannot be accessed in the
-   * playground.
+   * (e.g. 395747)
    */
+  asn: number;
   /**
-   *  (e.g. 395747)
+   * The organisation which owns the ASN of the incoming request.
+   * (e.g. Google Cloud)
    */
-  asn: number;
-  botManagement?: {
-    score: number;
-    staticResource: boolean;
-    verifiedBot: boolean;
-  };
+  asOrganization: string;
+  botManagement?: IncomingRequestCfPropertiesBotManagement;
   city?: string;
   clientTcpRtt: number;
   clientTrustScore?: number;
@@ -271,430 +605,696 @@ interface IncomingRequestCfProperties {
   timezone?: string;
   tlsVersion: string;
   tlsCipher: string;
-  tlsClientAuth: {
-    certIssuerDNLegacy: string;
-    certIssuerDN: string;
-    certPresented: '0' | '1';
-    certSubjectDNLegacy: string;
-    certSubjectDN: string;
-    certNotBefore: string; // In format "Dec 22 19:39:00 2018 GMT"
-    certNotAfter: string; // In format "Dec 22 19:39:00 2018 GMT"
-    certSerial: string;
-    certFingerprintSHA1: string;
-    certVerified: string; // “SUCCESS”, “FAILED:reason”, “NONE”
-  };
-}
-
-interface CfRequestInit extends Omit<RequestInit, 'cf'> {
-  cf?: RequestInitCfProperties;
-}
-
-interface RequestInit {
-  /**
-   * cf is a union of these two types because there are multiple
-   * scenarios in which it might be one or the other. If you need
-   * a type that only contains RequestInitCfProperties, use the
-   * CfRequestInit type.
-   *
-   * 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;
+  tlsClientAuth: IncomingRequestCfPropertiesTLSClientAuth;
 }
 
-declare function addEventListener(type: 'fetch', handler: (event: FetchEvent) => void): void;
-declare function addEventListener(type: 'scheduled', handler: (event: ScheduledEvent) => void): void;
-
-interface Request {
-  cf: IncomingRequestCfProperties;
+interface IncomingRequestCfPropertiesBotManagement {
+  score: number;
+  staticResource: boolean;
+  verifiedBot: boolean;
 }
 
-interface FormData {
-  [Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
+interface IncomingRequestCfPropertiesTLSClientAuth {
+  certIssuerDNLegacy: string;
+  certIssuerDN: string;
+  certPresented: "0" | "1";
+  certSubjectDNLegacy: string;
+  certSubjectDN: string;
   /**
-   * Returns an array of key, value pairs for every entry in the list.
+   * In format "Dec 22 19:39:00 2018 GMT"
    */
-  entries(): IterableIterator<[string, FormDataEntryValue]>;
+  certNotBefore: string;
   /**
-   * Returns a list of keys in the list.
+   * In format "Dec 22 19:39:00 2018 GMT"
    */
-  keys(): IterableIterator<string>;
+  certNotAfter: string;
+  certSerial: string;
+  certFingerprintSHA1: string;
   /**
-   * Returns a list of values in the list.
+   * "SUCCESS", "FAILED:reason", "NONE"
    */
-  values(): IterableIterator<FormDataEntryValue>;
+  certVerified: string;
 }
 
-interface Headers {
-  [Symbol.iterator](): IterableIterator<[string, string]>;
-  /**
-   * Returns an iterator allowing to go through all key/value pairs contained in this object.
-   */
-  entries(): IterableIterator<[string, string]>;
-  /**
-   * Returns an iterator allowing to go through all keys of the key/value pairs contained in this object.
-   */
-  keys(): IterableIterator<string>;
-  /**
-   * Returns an iterator allowing to go through all values of the key/value pairs contained in this object.
-   */
-  values(): IterableIterator<string>;
+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;
 }
 
-interface URLSearchParams {
-  [Symbol.iterator](): IterableIterator<[string, string]>;
-  /**
-   * Returns an array of key, value pairs for every entry in the search params.
-   */
-  entries(): IterableIterator<[string, string]>;
-  /**
-   * Returns a list of keys in the search params.
-   */
-  keys(): IterableIterator<string>;
-  /**
-   * Returns a list of values in the search params.
-   */
-  values(): IterableIterator<string>;
+/**
+ * Workers KV is a global, low-latency, key-value data store. It supports exceptionally high read volumes with low-latency,
+ * making it possible to build highly dynamic APIs and websites which respond as quickly as a cached static file would.
+ */
+interface KVNamespace {
+  get(key: string, options?: Partial<KVNamespaceGetOptions<undefined>>): Promise<string | null>;
+  get(key: string, type: "text"): Promise<string | null>;
+  get<ExpectedValue = unknown>(key: string, type: "json"): Promise<ExpectedValue | null>;
+  get(key: string, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
+  get(key: string, type: "stream"): Promise<ReadableStream | null>;
+  get(key: string, options: KVNamespaceGetOptions<"text">): Promise<string | null>;
+  get<ExpectedValue = unknown>(key: string, options: KVNamespaceGetOptions<"json">): Promise<ExpectedValue | null>;
+  get(key: string, options: KVNamespaceGetOptions<"arrayBuffer">): Promise<ArrayBuffer | null>;
+  get(key: string, options: KVNamespaceGetOptions<"stream">): Promise<ReadableStream | null>;
+  list<Metadata = unknown>(options?: KVNamespaceListOptions): Promise<KVNamespaceListResult<Metadata>>;
+  /**
+   * 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)
+   */
+  put(key: string, value: string | ArrayBuffer | ArrayBufferView | ReadableStream, options?: KVNamespacePutOptions): Promise<void>;
+  getWithMetadata<Metadata = unknown>(key: string, options?: Partial<KVNamespaceGetOptions<undefined>>): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<Metadata = unknown>(key: string, type: "text"): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(key: string, type: "json"): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
+  getWithMetadata<Metadata = unknown>(key: string, type: "arrayBuffer"): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
+  getWithMetadata<Metadata = unknown>(key: string, type: "stream"): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
+  getWithMetadata<Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"text">): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"json">): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
+  getWithMetadata<Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"arrayBuffer">): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
+  getWithMetadata<Metadata = unknown>(key: string, options: KVNamespaceGetOptions<"stream">): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
+  delete(name: string): Promise<void>;
 }
 
-interface ContentOptions {
-  /**
-   * Controls the way the HTMLRewriter treats inserted content.
-   *
-   * - true: Raw HTML
-   * - false: (Default) Text and any HTML will be escaped
-   */
-  html: boolean;
+interface KVNamespaceGetOptions<Type> {
+  type: Type;
+  cacheTtl?: number;
 }
 
-interface Element {
-  /**
-   *  The namespace URI of the element according to Infra Spec
-   * (https://infra.spec.whatwg.org/#namespaces).
-   */
-  namespaceURI: string;
-  /**
-   * e.g. "div"
-   */
-  tagName: string;
-  /**
-   * Read-Only - key/value pairs of attributes.
-   */
-  readonly attributes: IterableIterator<[string, string]>;
-  /**
-   * Indicates whether the element was removed/replaced in a previous handler
-   */
-  removed: boolean;
+interface KVNamespaceGetWithMetadataResult<Value, Metadata> {
+  value: Value | null;
+  metadata: Metadata | null;
+}
 
-  /**
-   * Returns the value for a given attribute name on the element, or null if it isn’t found.
-   */
-  getAttribute(name: string): string | null;
-  /**
-   * Returns a boolean indicating whether an attribute exists on the element.
-   */
-  hasAttribute(name: string): boolean;
-  /**
-   * Sets an attribute to a provided value, creating the attribute if it doesn’t exist.
-   */
-  setAttribute(name: string, value: string): Element;
-  /**
-   * Removes the attribute.
-   */
-  removeAttribute(name: string): Element;
-  /**
-   * Inserts content before the element.
-   */
-  before(content: string, options?: ContentOptions): Element;
-  /**
-   * Inserts content right after the element.
-   */
-  after(content: string, options?: ContentOptions): Element;
-  /**
-   * Inserts content right after the start tag of the element.
-   */
-  prepend(content: string, options?: ContentOptions): Element;
-  /**
-   * Inserts content right before the end tag of the element.
-   */
-  append(content: string, options?: ContentOptions): Element;
-  /**
-   * Removes the element and inserts content in place of it.
-   */
-  replace(content: string, options?: ContentOptions): Element;
-  /**
-   * Replaces content of the element.
-   */
-  setInnerContent(content: string, options?: ContentOptions): Element;
-  /**
-   * Removes the element with all its content.
-   */
-  remove(): Element;
-  /**
-   * Removes the start tag and end tag of the element, but keeps its inner content intact.
-   */
-  removeAndKeepContent(): Element;
+interface KVNamespaceListKey<Metadata> {
+  name: string;
+  expiration?: number;
+  metadata?: Metadata;
 }
 
-interface Text {
-  /**
-   * Indicates whether the element was removed/replaced in a previous handler.
-   */
-  removed: boolean;
-  /**
-   * Read-Only - The text contents of the chunk. Could be empty if the chunk
-   * is the last chunk of the text node.
-   */
-  readonly text: string;
+interface KVNamespaceListOptions {
+  limit?: number;
+  prefix?: string | null;
+  cursor?: string | null;
+}
+
+interface KVNamespaceListResult<Metadata> {
+  keys: KVNamespaceListKey<Metadata>[];
+  list_complete: boolean;
+  cursor?: string;
+}
+
+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;
+
+/**
+ * Transitionary name.
+ * @deprecated Use StreamPipeOptions
+ */
+interface PipeToOptions {
+  preventClose?: boolean;
+  preventAbort?: boolean;
+  preventCancel?: boolean;
+}
+
+declare abstract class PromiseRejectionEvent extends Event {
+  readonly promise: Promise<any>;
+  readonly reason: any;
+}
+
+interface ReadResult {
+  value?: any;
+  done: boolean;
+}
+
+declare abstract class ReadableStream {
+  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];
+}
+
+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 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;
+}
+
+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;
+  readonly cf?: IncomingRequestCfProperties;
+}
+
+interface RequestInit {
+  method?: string;
+  headers?: HeadersInit;
+  body?: BodyInit | null;
+  redirect?: string;
+  fetcher?: Fetcher | null;
   /**
-   * Read-Only - indicates whether the chunk is the last chunk of the text node.
+   * 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: { ... } })
    */
-  readonly lastInTextNode: boolean;
+  cf?: IncomingRequestCfProperties | RequestInitCfProperties;
+  signal?: AbortSignal | null;
+}
 
+/**
+ * In addition to the properties you can set in the RequestInit dict
+ * that you pass as an argument to the Request constructor, you can
+ * set certain properties of a `cf` object to control how Cloudflare
+ * features are applied to that new Request.
+ * 
+ * Note: Currently, these properties cannot be tested in the
+ * playground.
+ */
+interface RequestInitCfProperties {
+  cacheEverything?: boolean;
   /**
-   * Inserts content before the element.
+   * A request's cache key is what determines if two requests are
+   * "the same" for caching purposes. If a request has the same cache key
+   * as some previous request, then we can serve the same cached response for
+   * both. (e.g. 'some-key')
+   * 
+   * Only available for Enterprise customers.
    */
-  before(content: string, options?: ContentOptions): Element;
+  cacheKey?: string;
   /**
-   * Inserts content right after the element.
+   * Force response to be cached for a given number of seconds. (e.g. 300)
    */
-  after(content: string, options?: ContentOptions): Element;
+  cacheTtl?: number;
   /**
-   * Removes the element and inserts content in place of it.
+   * Force response to be cached for a given number of seconds based on the Origin status code.
+   * (e.g. { '200-299': 86400, '404': 1, '500-599': 0 })
    */
-  replace(content: string, options?: ContentOptions): Element;
+  cacheTtlByStatus?: Record<string, number>;
+  scrapeShield?: boolean;
+  apps?: boolean;
+  image?: RequestInitCfPropertiesImage;
+  minify?: RequestInitCfPropertiesImageMinify;
+  mirage?: boolean;
+  polish?: 'lossy' | 'lossless' | 'off';
   /**
-   * Removes the element with all its content.
+   * Redirects the request to an alternate origin server. You can use this,
+   * for example, to implement load balancing across several origins.
+   * (e.g.us-east.example.com)
+   * 
+   * Note - For security reasons, the hostname set in resolveOverride must
+   * be proxied on the same Cloudflare zone of the incoming request.
+   * Otherwise, the setting is ignored. CNAME hosts are allowed, so to
+   * resolve to a host under a different domain or a DNS only domain first
+   * declare a CNAME record within your own zone’s DNS mapping to the
+   * external hostname, set proxy on Cloudflare, then set resolveOverride
+   * to point to that CNAME record.
    */
-  remove(): Element;
+  resolveOverride?: string;
 }
 
-interface Comment {
-  /**
-   * Indicates whether the element was removed/replaced in a previous handler.
-   */
-  removed: boolean;
+interface RequestInitCfPropertiesImage extends BasicImageTransformations {
   /**
-   * This property can be assigned different values, to modify comment’s text.
+   * Device Pixel Ratio. Default 1. Multiplier for width/height that makes it
+   * easier to specify higher-DPI sizes in <img srcset>.
    */
-  text: string;
-
+  dpr?: number;
   /**
-   * Inserts content before the element.
+   * Quality setting from 1-100 (useful values are in 60-90 range). Lower values
+   * make images look worse, but load faster. The default is 85. It applies only
+   * to JPEG and WebP images. It doesn’t have any effect on PNG.
    */
-  before(content: string, options?: ContentOptions): Element;
+  quality?: number;
   /**
-   * Inserts content right after the element.
+   * Output format to generate. It can be:
+   *  - avif: generate images in AVIF format.
+   *  - webp: generate images in Google WebP format. Set quality to 100 to get
+   *    the WebP-lossless format.
+   *  - json: instead of generating an image, outputs information about the
+   *    image, in JSON format. The JSON object will contain image size
+   *    (before and after resizing), source image’s MIME type, file size, etc.
    */
-  after(content: string, options?: ContentOptions): Element;
+  format?: "avif" | "webp" | "json";
   /**
-   * Removes the element and inserts content in place of it.
+   * What EXIF data should be preserved in the output image. Note that EXIF
+   * rotation and embedded color profiles are always applied ("baked in" into
+   * the image), and aren't affected by this option. Note that if the Polish
+   * feature is enabled, all metadata may have been removed already and this
+   * option may have no effect.
+   *  - keep: Preserve most of EXIF metadata, including GPS location if there's
+   *    any.
+   *  - copyright: Only keep the copyright tag, and discard everything else.
+   *    This is the default behavior for JPEG files.
+   *  - none: Discard all invisible EXIF metadata. Currently WebP and PNG
+   *    output formats always discard metadata.
    */
-  replace(content: string, options?: ContentOptions): Element;
+  metadata?: "keep" | "copyright" | "none";
   /**
-   * Removes the element with all its content.
+   * Overlays are drawn in the order they appear in the array (last array
+   * entry is the topmost layer).
    */
-  remove(): Element;
+  draw?: RequestInitCfPropertiesImageDraw[];
 }
 
-interface Doctype {
-  readonly name: string | null;
-  /**
-   * Read-Only, The quoted string in the doctype after the PUBLIC atom.
-   */
-  readonly publicId: string | null;
-  /**
-   * Read-Only, The quoted string in the doctype after the SYSTEM atom or immediately after the publicId.
-   */
-  readonly systemId: string | null;
+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
+   * overlays we recommend using PNG or WebP images.
+   */
+  url: string;
+  /**
+   * Floating-point number between 0 (transparent) and 1 (opaque).
+   * For example, opacity: 0.5 makes overlay semitransparent.
+   */
+  opacity?: number;
+  /**
+   * - If set to true, the overlay image will be tiled to cover the entire
+   *   area. This is useful for stock-photo-like watermarks.
+   * - If set to "x", the overlay image will be tiled horizontally only
+   *   (form a line).
+   * - If set to "y", the overlay image will be tiled vertically only
+   *   (form a line).
+   */
+  repeat?: true | "x" | "y";
+  /**
+   * Position of the overlay image relative to a given edge. Each property is
+   * an offset in pixels. 0 aligns exactly to the edge. For example, left: 10
+   * positions left side of the overlay 10 pixels from the left edge of the
+   * image it's drawn over. bottom: 0 aligns bottom of the overlay with bottom
+   * of the background image.
+   * 
+   * Setting both left & right, or both top & bottom is an error.
+   * 
+   * If no position is specified, the image will be centered.
+   */
+  top?: number;
+  left?: number;
+  bottom?: number;
+  right?: number;
 }
 
-interface DocumentEnd {
-  /**
-   * Inserts content right after the end of the document.
-   */
-  append(content: string, options?: ContentOptions): DocumentEnd;
+interface RequestInitCfPropertiesImageMinify {
+  javascript?: boolean;
+  css?: boolean;
+  html?: boolean;
 }
 
-interface ElementHandlerOptionals {
-  /**
-   * An incoming element, such as `div`
-   */
-  element?(element: Element): void | Promise<void>;
-  /**
-   * An incoming comment
-   */
-  comments?(comment: Comment): void | Promise<void>;
-  /**
-   * An incoming piece of text
-   */
-  text?(text: Text): void | Promise<void>;
+/**
+ * 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;
+  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;
 }
 
-// See https://stackoverflow.com/a/49725198
-type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> &
-  {
-    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
-  }[Keys];
+interface ResponseInit {
+  status?: number;
+  statusText?: string;
+  headers?: HeadersInit;
+  cf?: Object;
+  webSocket?: WebSocket | null;
+  encodeBody?: string;
+}
 
-type ElementHandler = RequireAtLeastOne<ElementHandlerOptionals, 'element' | 'comments' | 'text'>;
+/**
+ * Back compat for code migrating from older definitions.
+ * @deprecated Use ResponseInit instead.
+ */
+declare type ResponseInitializerDict = ResponseInit;
 
-interface DocumentHandler {
-  /**
-   * An incoming doctype, such as <!DOCTYPE html>
-   */
-  doctype(doctype: Doctype): void | Promise<void>;
-  /**
-   * An incoming comment
-   */
-  comments(comment: Comment): void | Promise<void>;
-  /**
-   * An incoming piece of text
-   */
-  text(text: Text): void | Promise<void>;
-  /**
-   * The ending of the document
-   */
-  end(end: DocumentEnd): void | Promise<void>;
+interface RsaOtherPrimesInfo {
+  r?: string;
+  d?: string;
+  t?: string;
 }
 
-declare class HTMLRewriter {
-  constructor();
-  public on(selector: string, handlers: ElementHandler): HTMLRewriter;
-  public onDocument(handlers: DocumentHandler): HTMLRewriter;
-  public transform(response: Response): Response;
+interface ScheduledController {
+  readonly scheduledTime: number;
+  readonly cron: string;
+  noRetry(): void;
 }
 
-declare interface CacheStorage {
-  default: Cache;
+declare abstract class ScheduledEvent extends Event {
+  readonly scheduledTime: number;
+  readonly cron: string;
+  noRetry(): void;
+  waitUntil(promise: Promise<any>): void;
 }
 
-type KVValue<Value> = Promise<Value | null>;
-type KVValueWithMetadata<Value, Metadata> = Promise<{
-  value: Value | null;
-  metadata: Metadata | null;
-}>;
+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;
+  fetch(request: Request | string, requestInitr?: RequestInit | Request): Promise<Response>;
+  readonly self: ServiceWorkerGlobalScope;
+  readonly crypto: Crypto;
+  readonly caches: CacheStorage;
+  readonly console: Console;
+}
 
-interface KVNamespace {
-  get(key: string): KVValue<string>;
-  get(key: string, type: 'text'): KVValue<string>;
-  get<ExpectedValue = unknown>(key: string, type: 'json'): KVValue<ExpectedValue>;
-  get(key: string, type: 'arrayBuffer'): KVValue<ArrayBuffer>;
-  get(key: string, type: 'stream'): KVValue<ReadableStream>;
-
-  getWithMetadata<Metadata = unknown>(key: string): KVValueWithMetadata<string, Metadata>;
-  getWithMetadata<Metadata = unknown>(
-    key: string,
-    type: 'text'
-  ): KVValueWithMetadata<string, Metadata>;
-  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
-    key: string,
-    type: 'json'
-  ): KVValueWithMetadata<ExpectedValue, Metadata>;
-  getWithMetadata<Metadata = unknown>(
-    key: string,
-    type: 'arrayBuffer'
-  ): KVValueWithMetadata<ArrayBuffer, Metadata>;
-  getWithMetadata<Metadata = unknown>(
-    key: string,
-    type: 'stream'
-  ): KVValueWithMetadata<ReadableStream, Metadata>;
-
-  put(
-    key: string,
-    value: string | ReadableStream | ArrayBuffer | FormData,
-    options?: {
-      expiration?: string | number;
-      expirationTtl?: string | number;
-      metadata?: any;
-    }
-  ): Promise<void>;
-
-  delete(key: string): Promise<void>;
-
-  list(options?: {
-    prefix?: string;
-    limit?: number;
-    cursor?: string;
-  }): Promise<{
-    keys: { name: string; expiration?: number; metadata?: unknown }[];
-    list_complete: boolean;
-    cursor?: string;
-  }>;
-}
-
-interface DurableObjectEntries<T> {
-  [key: string]: T;
+declare type StreamPipeOptions = PipeToOptions;
+
+interface StreamQueuingStrategy {
+  highWaterMark?: number;
+  size(chunk: ArrayBuffer): number;
 }
 
-interface DurableObjectListOptions {
-  start?: string;
-  end?: string;
-  reverse?: boolean;
-  limit?: number;
-  prefix?: string;                     
+declare abstract class SubtleCrypto {
+  encrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, plainText: ArrayBuffer): Promise<ArrayBuffer>;
+  decrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, cipherText: ArrayBuffer): Promise<ArrayBuffer>;
+  sign(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
+  verify(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean>;
+  digest(algorithm: string | SubtleCryptoHashAlgorithm, data: ArrayBuffer): Promise<ArrayBuffer>;
+  generateKey(algorithm: string | SubtleCryptoGenerateKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey | CryptoKeyPair>;
+  deriveKey(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, derivedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  deriveBits(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, length: number | null): Promise<ArrayBuffer>;
+  importKey(format: string, keyData: ArrayBuffer | JsonWebKey, algorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  exportKey(format: string, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
+  wrapKey(format: string, key: CryptoKey, wrappingKey: CryptoKey, wrapAlgorithm: string | SubtleCryptoEncryptAlgorithm): Promise<ArrayBuffer>;
+  unwrapKey(format: string, wrappedKey: ArrayBuffer, unwrappingKey: CryptoKey, unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm, unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
 }
 
-interface DurableObjectOperator {
-  get<T = unknown>(key: string): Promise<T>;
-  get<T = unknown>(keys: Array<string>): Promise<Map<string, T>>;
-  put<T = unknown>(key: string, value: T): Promise<void>;
-  put<T = unknown>(entries: DurableObjectEntries<T>): Promise<void>;
-  delete(key: string): Promise<boolean>;
-  delete(keys: Array<string>): Promise<number>;
-  deleteAll(): Promise<void>;
-  list<T = unknown>(options?: DurableObjectListOptions): Promise<Map<string, T>>;
+interface SubtleCryptoDeriveKeyAlgorithm {
+  name: string;
+  salt?: ArrayBuffer;
+  iterations?: number;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  public?: CryptoKey;
+  info?: ArrayBuffer;
 }
 
-interface DurableObjectTransaction extends DurableObjectOperator {
-  rollback(): void;
+interface SubtleCryptoEncryptAlgorithm {
+  name: string;
+  iv?: ArrayBuffer;
+  additionalData?: ArrayBuffer;
+  tagLength?: number;
+  counter?: ArrayBuffer;
+  length?: number;
+  label?: ArrayBuffer;
 }
 
-interface DurableObjectStorage extends DurableObjectOperator {
-  transaction(
-    closure: (txn: DurableObjectStorage) => Promise<void>
-  ): Promise<void>;
+interface SubtleCryptoGenerateKeyAlgorithm {
+  name: string;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  modulusLength?: number;
+  publicExponent?: ArrayBuffer;
+  length?: number;
+  namedCurve?: string;
 }
 
-interface DurableObjectState {
-  id: DurableObjectId;
-  storage: DurableObjectStorage;
-  /**
-   * Use this method to notify the runtime to wait for asynchronous tasks
-   * (e.g. logging, analytics to third-party services, streaming and caching).
-   */
-  waitUntil(promise: Promise<any>): void;
+interface SubtleCryptoHashAlgorithm {
+  name: string;
+}
+
+interface SubtleCryptoImportKeyAlgorithm {
+  name: string;
+  hash?: string | SubtleCryptoHashAlgorithm;
+  length?: number;
+  namedCurve?: string;
+  compressed?: boolean;
 }
 
 /**
- * DurableObject is a class that defines a template for creating Durable Objects
+ * 
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
  */
-interface DurableObject {
-  fetch: (request: Request) => Promise<Response>;
+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;
+}
+
+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 TextDecoder {
+  constructor(label?: "utf-8" | "utf8" | "unicode-1-1-utf-8", options?: TextDecoderConstructorOptions);
+  decode(input?: ArrayBuffer, options?: TextDecoderDecodeOptions): string;
+  readonly encoding: string;
+  readonly fatal: boolean;
+  readonly ignoreBOM: boolean;
+}
+
+interface TextDecoderConstructorOptions {
+  fatal: boolean;
+  ignoreBOM: boolean;
+}
+
+interface TextDecoderDecodeOptions {
+  stream: boolean;
+}
+
+declare class TextEncoder {
+  constructor();
+  encode(input?: string): Uint8Array;
+  encodeInto(input: string, buffer: Uint8Array): TextEncoderEncodeIntoResult;
+  readonly encoding: string;
+}
+
+interface TextEncoderEncodeIntoResult {
+  read: number;
+  written: number;
+}
+
+declare class TransformStream {
+  constructor();
+  readonly readable: ReadableStream;
+  readonly writable: WritableStream;
+}
+
+declare class URL {
+  constructor(url: string, base?: string);
+  href: string;
+  readonly origin: string;
+  protocol: string;
+  username: string;
+  password: string;
+  host: string;
+  hostname: string;
+  port: string;
+  pathname: string;
+  search: string;
+  readonly searchParams: URLSearchParams;
+  hash: string;
+  toString(): string;
+  toJSON(): string;
+}
+
+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, key: string, value: string, parent: URLSearchParams) => void, thisArg?: This): void;
+  [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
+  toString(): string;
 }
 
+declare type URLSearchParamsInit = URLSearchParams | string | Record<string, string> | ([key: string, value: string])[];
+
 /**
- * DurableObjectStub is a client object used to send requests to a remote Durable Object
+ * 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.
  */
-interface DurableObjectStub {
-  name?: string;
-  id: DurableObjectId;
-  fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+declare type URLSearchParamsInitializer = URLSearchParamsInit;
+
+declare abstract class WebSocket extends EventTarget<WebSocketEventMap> {
+  accept(): void;
+  send(message: ArrayBuffer | string): void;
+  close(code?: number, reason?: string): void;
 }
 
-interface DurableObjectId {
-  name?: string;
-  toString: () => string;
+declare type WebSocketEventMap = { close: CloseEvent; message: MessageEvent; };
+
+declare const WebSocketPair: { new(): { 0: WebSocket; 1: WebSocket; }; };
+
+declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {
+
 }
 
-interface DurableObjectNamespace {
-  newUniqueId: () => DurableObjectId;
-  idFromName: (name: string) => DurableObjectId;
-  idFromString: (hexId: string) => DurableObjectId;
+declare type WorkerGlobalScopeEventMap = { fetch: FetchEvent; scheduled: ScheduledEvent; unhandledrejection: PromiseRejectionEvent; rejectionhandled: PromiseRejectionEvent; };
+
+declare abstract class WritableStream {
+  readonly locked: boolean;
+  abort(reason: any): Promise<void>;
+  close(): Promise<void>;
+  getWriter(): WritableStreamDefaultWriter;
+}
 
-  get: (id: DurableObjectId) => DurableObjectStub;
+declare class WritableStreamDefaultWriter {
+  constructor(stream: WritableStream);
+  readonly closed: 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 function queueMicrotask(task: Function): void;
+
+declare function removeEventListener<Type extends keyof WorkerGlobalScopeEventMap>(type: Type, handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
+
+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;
+