@cloudflare/workers-types 4.20240320.1 → 4.20240402.0

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

@@ -16,8 +16,15 @@ and limitations under the License.
 // noinspection JSUnusedGlobalSymbols
 declare class DOMException extends Error {
   constructor(message?: string, name?: string);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/message) */
   readonly message: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/name) */
   readonly name: string;
+  /**
+   * @deprecated
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DOMException/code)
+   */
   readonly code: number;
   readonly stack: any;
   static readonly INDEX_SIZE_ERR: number;
@@ -56,30 +63,61 @@ declare type WorkerGlobalScopeEventMap = {
 declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {
   EventTarget: typeof EventTarget;
 }
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */
 declare interface Console {
   "assert"(condition?: boolean, ...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear_static) */
   clear(): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count_static) */
   count(label?: string): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/countReset_static) */
   countReset(label?: string): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug_static) */
   debug(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir_static) */
   dir(item?: any, options?: any): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml_static) */
   dirxml(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error_static) */
   error(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group_static) */
   group(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed_static) */
   groupCollapsed(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd_static) */
   groupEnd(): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info_static) */
   info(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log_static) */
   log(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table_static) */
   table(tabularData?: any, properties?: string[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time_static) */
   time(label?: string): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd_static) */
   timeEnd(label?: string): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog_static) */
   timeLog(label?: string, ...data: any[]): void;
   timeStamp(label?: string): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace_static) */
   trace(...data: any[]): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn_static) */
   warn(...data: any[]): void;
 }
 declare const console: Console;
 declare type BufferSource = ArrayBufferView | ArrayBuffer;
+declare type TypedArray =
+  | Int8Array
+  | Uint8Array
+  | Uint8ClampedArray
+  | Int16Array
+  | Uint16Array
+  | Int32Array
+  | Uint32Array
+  | Float32Array
+  | Float64Array
+  | BigInt64Array
+  | BigUint64Array;
 declare namespace WebAssembly {
   class CompileError extends Error {
     constructor(message?: string);
@@ -154,7 +192,11 @@ declare namespace WebAssembly {
   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. */
+/**
+ * This ServiceWorker API interface represents the global execution context of a service worker.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ServiceWorkerGlobalScope)
+ */
 declare interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   DOMException: typeof DOMException;
   WorkerGlobalScope: typeof WorkerGlobalScope;
@@ -178,7 +220,7 @@ declare interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   structuredClone<T>(value: T, options?: StructuredSerializeOptions): T;
   fetch(
     input: RequestInfo,
-    init?: RequestInit<RequestInitCfProperties>
+    init?: RequestInit<RequestInitCfProperties>,
   ): Promise<Response>;
   self: ServiceWorkerGlobalScope;
   crypto: Crypto;
@@ -247,49 +289,64 @@ declare interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
 declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(
   type: Type,
   handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
-  options?: EventTargetAddEventListenerOptions | boolean
+  options?: EventTargetAddEventListenerOptions | boolean,
 ): void;
 declare function removeEventListener<
-  Type extends keyof WorkerGlobalScopeEventMap
+  Type extends keyof WorkerGlobalScopeEventMap,
 >(
   type: Type,
   handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
-  options?: EventTargetEventListenerOptions | boolean
+  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. */
+/**
+ * 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.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent)
+ */
 declare function dispatchEvent(
-  event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]
+  event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap],
 ): boolean;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/btoa) */
 declare function btoa(data: string): string;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/atob) */
 declare function atob(data: string): string;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setTimeout) */
 declare function setTimeout(
   callback: (...args: any[]) => void,
-  msDelay?: number
+  msDelay?: number,
 ): number;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setTimeout) */
 declare function setTimeout<Args extends any[]>(
   callback: (...args: Args) => void,
   msDelay?: number,
   ...args: Args
 ): number;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/clearTimeout) */
 declare function clearTimeout(timeoutId: number | null): void;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setInterval) */
 declare function setInterval(
   callback: (...args: any[]) => void,
-  msDelay?: number
+  msDelay?: number,
 ): number;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/setInterval) */
 declare function setInterval<Args extends any[]>(
   callback: (...args: Args) => void,
   msDelay?: number,
   ...args: Args
 ): number;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/clearInterval) */
 declare function clearInterval(timeoutId: number | null): void;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/queueMicrotask) */
 declare function queueMicrotask(task: Function): void;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/structuredClone) */
 declare function structuredClone<T>(
   value: T,
-  options?: StructuredSerializeOptions
+  options?: StructuredSerializeOptions,
 ): T;
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/fetch) */
 declare function fetch(
   input: RequestInfo,
-  init?: RequestInit<RequestInitCfProperties>
+  init?: RequestInit<RequestInitCfProperties>,
 ): Promise<Response>;
 declare const self: ServiceWorkerGlobalScope;
 declare const crypto: Crypto;
@@ -304,41 +361,41 @@ declare interface ExecutionContext {
 }
 declare type ExportedHandlerFetchHandler<
   Env = unknown,
-  CfHostMetadata = unknown
+  CfHostMetadata = unknown,
 > = (
   request: Request<CfHostMetadata, IncomingRequestCfProperties<CfHostMetadata>>,
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => Response | Promise<Response>;
 declare type ExportedHandlerTailHandler<Env = unknown> = (
   events: TraceItem[],
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => void | Promise<void>;
 declare type ExportedHandlerTraceHandler<Env = unknown> = (
   traces: TraceItem[],
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => void | Promise<void>;
 declare type ExportedHandlerScheduledHandler<Env = unknown> = (
   controller: ScheduledController,
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => void | Promise<void>;
 declare type ExportedHandlerQueueHandler<Env = unknown, Message = unknown> = (
   batch: MessageBatch<Message>,
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => void | Promise<void>;
 declare type ExportedHandlerTestHandler<Env = unknown> = (
   controller: TestController,
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => void | Promise<void>;
 declare interface ExportedHandler<
   Env = unknown,
   QueueHandlerMessage = unknown,
-  CfHostMetadata = unknown
+  CfHostMetadata = unknown,
 > {
   fetch?: ExportedHandlerFetchHandler<Env, CfHostMetadata>;
   tail?: ExportedHandlerTailHandler<Env>;
@@ -352,12 +409,20 @@ declare interface StructuredSerializeOptions {
   transfer?: any[];
 }
 declare abstract class PromiseRejectionEvent extends Event {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/promise) */
   readonly promise: Promise<any>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/PromiseRejectionEvent/reason) */
   readonly reason: any;
 }
-/** Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API. */
+/**
+ * Provides access to performance-related information for the current page. It's part of the High Resolution Time API, but is enhanced by the Performance Timeline API, the Navigation Timing API, the User Timing API, and the Resource Timing API.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance)
+ */
 declare interface Performance {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/timeOrigin) */
   readonly timeOrigin: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Performance/now) */
   now(): number;
 }
 declare interface AlarmInvocationInfo {
@@ -369,36 +434,42 @@ declare interface DurableObject {
   alarm?(): void | Promise<void>;
   webSocketMessage?(
     ws: WebSocket,
-    message: string | ArrayBuffer
+    message: string | ArrayBuffer,
   ): void | Promise<void>;
   webSocketClose?(
     ws: WebSocket,
     code: number,
     reason: string,
-    wasClean: boolean
+    wasClean: boolean,
   ): void | Promise<void>;
   webSocketError?(ws: WebSocket, error: unknown): void | Promise<void>;
 }
-declare interface DurableObjectStub extends Fetcher {
+declare type DurableObjectStub<
+  T extends Rpc.DurableObjectBranded | undefined = undefined,
+> = Fetcher<
+  T,
+  "alarm" | "webSocketMessage" | "webSocketClose" | "webSocketError"
+> & {
   readonly id: DurableObjectId;
   readonly name?: string;
-}
+};
 declare interface DurableObjectId {
   toString(): string;
   equals(other: DurableObjectId): boolean;
   readonly name?: string;
 }
-declare interface DurableObjectNamespace {
+declare interface DurableObjectNamespace<
+  T extends Rpc.DurableObjectBranded | undefined = undefined,
+> {
   newUniqueId(
-    options?: DurableObjectNamespaceNewUniqueIdOptions
+    options?: DurableObjectNamespaceNewUniqueIdOptions,
   ): DurableObjectId;
   idFromName(name: string): DurableObjectId;
   idFromString(id: string): DurableObjectId;
-  get(
-    id: DurableObjectId,
-    options?: DurableObjectNamespaceGetDurableObjectOptions
-  ): DurableObjectStub;
-  jurisdiction(jurisdiction: DurableObjectJurisdiction): DurableObjectNamespace;
+  get(id: DurableObjectId): DurableObjectStub<T>;
+  jurisdiction(
+    jurisdiction: DurableObjectJurisdiction,
+  ): DurableObjectNamespace<T>;
 }
 declare type DurableObjectJurisdiction = "eu" | "fedramp";
 declare interface DurableObjectNamespaceNewUniqueIdOptions {
@@ -434,23 +505,23 @@ declare interface DurableObjectState {
 declare interface DurableObjectTransaction {
   get<T = unknown>(
     key: string,
-    options?: DurableObjectGetOptions
+    options?: DurableObjectGetOptions,
   ): Promise<T | undefined>;
   get<T = unknown>(
     keys: string[],
-    options?: DurableObjectGetOptions
+    options?: DurableObjectGetOptions,
   ): Promise<Map<string, T>>;
   list<T = unknown>(
-    options?: DurableObjectListOptions
+    options?: DurableObjectListOptions,
   ): Promise<Map<string, T>>;
   put<T>(
     key: string,
     value: T,
-    options?: DurableObjectPutOptions
+    options?: DurableObjectPutOptions,
   ): Promise<void>;
   put<T>(
     entries: Record<string, T>,
-    options?: DurableObjectPutOptions
+    options?: DurableObjectPutOptions,
   ): Promise<void>;
   delete(key: string, options?: DurableObjectPutOptions): Promise<boolean>;
   delete(keys: string[], options?: DurableObjectPutOptions): Promise<number>;
@@ -458,41 +529,41 @@ declare interface DurableObjectTransaction {
   getAlarm(options?: DurableObjectGetAlarmOptions): Promise<number | null>;
   setAlarm(
     scheduledTime: number | Date,
-    options?: DurableObjectSetAlarmOptions
+    options?: DurableObjectSetAlarmOptions,
   ): Promise<void>;
   deleteAlarm(options?: DurableObjectSetAlarmOptions): Promise<void>;
 }
 declare interface DurableObjectStorage {
   get<T = unknown>(
     key: string,
-    options?: DurableObjectGetOptions
+    options?: DurableObjectGetOptions,
   ): Promise<T | undefined>;
   get<T = unknown>(
     keys: string[],
-    options?: DurableObjectGetOptions
+    options?: DurableObjectGetOptions,
   ): Promise<Map<string, T>>;
   list<T = unknown>(
-    options?: DurableObjectListOptions
+    options?: DurableObjectListOptions,
   ): Promise<Map<string, T>>;
   put<T>(
     key: string,
     value: T,
-    options?: DurableObjectPutOptions
+    options?: DurableObjectPutOptions,
   ): Promise<void>;
   put<T>(
     entries: Record<string, T>,
-    options?: DurableObjectPutOptions
+    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>
+    closure: (txn: DurableObjectTransaction) => Promise<T>,
   ): Promise<T>;
   getAlarm(options?: DurableObjectGetAlarmOptions): Promise<number | null>;
   setAlarm(
     scheduledTime: number | Date,
-    options?: DurableObjectSetAlarmOptions
+    options?: DurableObjectSetAlarmOptions,
   ): Promise<void>;
   deleteAlarm(options?: DurableObjectSetAlarmOptions): Promise<void>;
   sync(): Promise<void>;
@@ -539,32 +610,101 @@ declare interface AnalyticsEngineDataPoint {
 }
 declare class Event {
   constructor(type: string, init?: EventInit);
-  /** Returns the type of event, e.g. "click", "hashchange", or "submit". */
+  /**
+   * Returns the type of event, e.g. "click", "hashchange", or "submit".
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/type)
+   */
   readonly type: string;
-  /** Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE. */
+  /**
+   * Returns the event's phase, which is one of NONE, CAPTURING_PHASE, AT_TARGET, and BUBBLING_PHASE.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/eventPhase)
+   */
   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. */
+  /**
+   * 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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/composed)
+   */
   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. */
+  /**
+   * 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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/bubbles)
+   */
   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. */
+  /**
+   * 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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelable)
+   */
   readonly cancelable: boolean;
-  /** Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise. */
+  /**
+   * Returns true if preventDefault() was invoked successfully to indicate cancelation, and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/defaultPrevented)
+   */
   readonly defaultPrevented: boolean;
-  /** @deprecated */
+  /**
+   * @deprecated
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/returnValue)
+   */
   readonly returnValue: boolean;
-  /** Returns the object whose event listener's callback is currently being invoked. */
+  /**
+   * Returns the object whose event listener's callback is currently being invoked.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/currentTarget)
+   */
   readonly currentTarget?: EventTarget;
-  /** @deprecated */
+  /**
+   * @deprecated
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/srcElement)
+   */
   readonly srcElement?: EventTarget;
-  /** Returns the event's timestamp as the number of milliseconds measured relative to the time origin. */
+  /**
+   * Returns the event's timestamp as the number of milliseconds measured relative to the time origin.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/timeStamp)
+   */
   readonly timeStamp: number;
-  /** Returns true if event was dispatched by the user agent, and false otherwise. */
+  /**
+   * Returns true if event was dispatched by the user agent, and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/isTrusted)
+   */
   readonly isTrusted: boolean;
+  /**
+   * @deprecated
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/cancelBubble)
+   */
   cancelBubble: boolean;
+  /**
+   * Invoking this method prevents event from reaching any registered event listeners after the current one finishes running and, when dispatched in a tree, also prevents event from reaching any other objects.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/stopImmediatePropagation)
+   */
   stopImmediatePropagation(): void;
+  /**
+   * If invoked when the cancelable attribute value is true, and while executing a listener for the event with passive set to false, signals to the operation that caused event to be dispatched that it needs to be canceled.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/preventDefault)
+   */
   preventDefault(): void;
+  /**
+   * When dispatched in a tree, invoking this method prevents event from reaching any objects other than the current object.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/stopPropagation)
+   */
   stopPropagation(): void;
+  /**
+   * Returns the invocation target objects of event's path (objects on which listeners will be invoked), except for any nodes in shadow trees of which the shadow root's mode is "closed" that are not reachable from event's currentTarget.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Event/composedPath)
+   */
   composedPath(): EventTarget[];
   static readonly NONE: number;
   static readonly CAPTURING_PHASE: number;
@@ -577,28 +717,55 @@ declare interface EventInit {
   composed?: boolean;
 }
 declare type EventListener<EventType extends Event = Event> = (
-  event: EventType
+  event: EventType,
 ) => void;
 declare interface EventListenerObject<EventType extends Event = Event> {
   handleEvent(event: EventType): void;
 }
 declare type EventListenerOrEventListenerObject<
-  EventType extends Event = Event
+  EventType extends Event = Event,
 > = EventListener<EventType> | EventListenerObject<EventType>;
 declare class EventTarget<
-  EventMap extends Record<string, Event> = Record<string, Event>
+  EventMap extends Record<string, Event> = Record<string, Event>,
 > {
   constructor();
+  /**
+   * Appends an event listener for events whose type attribute value is type. The callback argument sets the callback that will be invoked when the event is dispatched.
+   *
+   * The options argument sets listener-specific options. For compatibility this can be a boolean, in which case the method behaves exactly as if the value was specified as options's capture.
+   *
+   * When set to true, options's capture prevents callback from being invoked when the event's eventPhase attribute value is BUBBLING_PHASE. When false (or not present), callback will not be invoked when event's eventPhase attribute value is CAPTURING_PHASE. Either way, callback will be invoked if event's eventPhase attribute value is AT_TARGET.
+   *
+   * When set to true, options's passive indicates that the callback will not cancel the event by invoking preventDefault(). This is used to enable performance optimizations described in § 2.8 Observing event listeners.
+   *
+   * When set to true, options's once indicates that the callback will only be invoked once after which the event listener will be removed.
+   *
+   * If an AbortSignal is passed for options's signal, then the event listener will be removed when signal is aborted.
+   *
+   * The event listener is appended to target's event listener list and is not appended if it has the same type, callback, and capture.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/addEventListener)
+   */
   addEventListener<Type extends keyof EventMap>(
     type: Type,
     handler: EventListenerOrEventListenerObject<EventMap[Type]>,
-    options?: EventTargetAddEventListenerOptions | boolean
+    options?: EventTargetAddEventListenerOptions | boolean,
   ): void;
+  /**
+   * Removes the event listener in target's event listener list with the same type, callback, and options.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/removeEventListener)
+   */
   removeEventListener<Type extends keyof EventMap>(
     type: Type,
     handler: EventListenerOrEventListenerObject<EventMap[Type]>,
-    options?: EventTargetEventListenerOptions | boolean
+    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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventTarget/dispatchEvent)
+   */
   dispatchEvent(event: EventMap[keyof EventMap]): boolean;
 }
 declare interface EventTargetEventListenerOptions {
@@ -615,17 +782,34 @@ declare interface EventTargetHandlerObject {
 }
 declare class AbortController {
   constructor();
-  /** Returns the AbortSignal object associated with this object. */
+  /**
+   * Returns the AbortSignal object associated with this object.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/signal)
+   */
   readonly signal: AbortSignal;
+  /**
+   * Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortController/abort)
+   */
   abort(reason?: any): void;
 }
 declare abstract class AbortSignal extends EventTarget {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/abort_static) */
   static abort(reason?: any): AbortSignal;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/timeout_static) */
   static timeout(delay: number): AbortSignal;
   static any(signals: AbortSignal[]): AbortSignal;
-  /** Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise. */
+  /**
+   * Returns true if this AbortSignal's AbortController has signaled to abort, and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/aborted)
+   */
   readonly aborted: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/reason) */
   readonly reason: any;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/AbortSignal/throwIfAborted) */
   throwIfAborted(): void;
 }
 declare interface Scheduler {
@@ -635,10 +819,16 @@ declare interface SchedulerWaitOptions {
   signal?: AbortSignal;
 }
 declare abstract class ExtendableEvent extends Event {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ExtendableEvent/waitUntil) */
   waitUntil(promise: Promise<any>): void;
 }
 declare class CustomEvent<T = any> extends Event {
   constructor(type: string, init?: CustomEventCustomEventInit);
+  /**
+   * Returns any custom data event was created with. Typically used for synthetic events.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CustomEvent/detail)
+   */
   get detail(): T;
 }
 declare interface CustomEventCustomEventInit {
@@ -650,13 +840,19 @@ declare interface CustomEventCustomEventInit {
 declare class Blob {
   constructor(
     bits?: ((ArrayBuffer | ArrayBufferView) | string | Blob)[],
-    options?: BlobOptions
+    options?: BlobOptions,
   );
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/size) */
   readonly size: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/type) */
   readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/slice) */
   slice(start?: number, end?: number, type?: string): Blob;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/arrayBuffer) */
   arrayBuffer(): Promise<ArrayBuffer>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/text) */
   text(): Promise<string>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Blob/stream) */
   stream(): ReadableStream;
 }
 declare interface BlobOptions {
@@ -666,9 +862,11 @@ declare class File extends Blob {
   constructor(
     bits: ((ArrayBuffer | ArrayBufferView) | string | Blob)[] | undefined,
     name: string,
-    options?: FileOptions
+    options?: FileOptions,
   );
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/name) */
   readonly name: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/File/lastModified) */
   readonly lastModified: number;
 }
 declare interface FileOptions {
@@ -676,6 +874,7 @@ declare interface FileOptions {
   lastModified?: number;
 }
 declare abstract class CacheStorage {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CacheStorage/open) */
   open(cacheName: string): Promise<Cache>;
   readonly default: Cache;
 }
@@ -683,7 +882,7 @@ declare abstract class Cache {
   delete(request: RequestInfo, options?: CacheQueryOptions): Promise<boolean>;
   match(
     request: RequestInfo,
-    options?: CacheQueryOptions
+    options?: CacheQueryOptions,
   ): Promise<Response | undefined>;
   put(request: RequestInfo, response: Response): Promise<void>;
 }
@@ -691,8 +890,13 @@ declare interface CacheQueryOptions {
   ignoreMethod?: boolean;
 }
 declare abstract class Crypto {
-  /** Available only in secure contexts. */
+  /**
+   * Available only in secure contexts.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/subtle)
+   */
   readonly subtle: SubtleCrypto;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/getRandomValues) */
   getRandomValues<
     T extends
       | Int8Array
@@ -702,8 +906,13 @@ declare abstract class Crypto {
       | Int32Array
       | Uint32Array
       | BigInt64Array
-      | BigUint64Array
+      | BigUint64Array,
   >(buffer: T): T;
+  /**
+   * Available only in secure contexts.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Crypto/randomUUID)
+   */
   randomUUID(): string;
   DigestStream: typeof DigestStream;
 }
@@ -711,59 +920,63 @@ declare abstract class SubtleCrypto {
   encrypt(
     algorithm: string | SubtleCryptoEncryptAlgorithm,
     key: CryptoKey,
-    plainText: ArrayBuffer | ArrayBufferView
+    plainText: ArrayBuffer | ArrayBufferView,
   ): Promise<ArrayBuffer>;
   decrypt(
     algorithm: string | SubtleCryptoEncryptAlgorithm,
     key: CryptoKey,
-    cipherText: ArrayBuffer | ArrayBufferView
+    cipherText: ArrayBuffer | ArrayBufferView,
   ): Promise<ArrayBuffer>;
   sign(
     algorithm: string | SubtleCryptoSignAlgorithm,
     key: CryptoKey,
-    data: ArrayBuffer | ArrayBufferView
+    data: ArrayBuffer | ArrayBufferView,
   ): Promise<ArrayBuffer>;
   verify(
     algorithm: string | SubtleCryptoSignAlgorithm,
     key: CryptoKey,
     signature: ArrayBuffer | ArrayBufferView,
-    data: ArrayBuffer | ArrayBufferView
+    data: ArrayBuffer | ArrayBufferView,
   ): Promise<boolean>;
   digest(
     algorithm: string | SubtleCryptoHashAlgorithm,
-    data: ArrayBuffer | ArrayBufferView
+    data: ArrayBuffer | ArrayBufferView,
   ): Promise<ArrayBuffer>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/generateKey) */
   generateKey(
     algorithm: string | SubtleCryptoGenerateKeyAlgorithm,
     extractable: boolean,
-    keyUsages: string[]
+    keyUsages: string[],
   ): Promise<CryptoKey | CryptoKeyPair>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/deriveKey) */
   deriveKey(
     algorithm: string | SubtleCryptoDeriveKeyAlgorithm,
     baseKey: CryptoKey,
     derivedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm,
     extractable: boolean,
-    keyUsages: string[]
+    keyUsages: string[],
   ): Promise<CryptoKey>;
   deriveBits(
     algorithm: string | SubtleCryptoDeriveKeyAlgorithm,
     baseKey: CryptoKey,
-    length: number | null
+    length: number | null,
   ): Promise<ArrayBuffer>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/importKey) */
   importKey(
     format: string,
     keyData: (ArrayBuffer | ArrayBufferView) | JsonWebKey,
     algorithm: string | SubtleCryptoImportKeyAlgorithm,
     extractable: boolean,
-    keyUsages: string[]
+    keyUsages: string[],
   ): Promise<CryptoKey>;
   exportKey(format: string, key: CryptoKey): Promise<ArrayBuffer | JsonWebKey>;
   wrapKey(
     format: string,
     key: CryptoKey,
     wrappingKey: CryptoKey,
-    wrapAlgorithm: string | SubtleCryptoEncryptAlgorithm
+    wrapAlgorithm: string | SubtleCryptoEncryptAlgorithm,
   ): Promise<ArrayBuffer>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/SubtleCrypto/unwrapKey) */
   unwrapKey(
     format: string,
     wrappedKey: ArrayBuffer | ArrayBufferView,
@@ -771,16 +984,19 @@ declare abstract class SubtleCrypto {
     unwrapAlgorithm: string | SubtleCryptoEncryptAlgorithm,
     unwrappedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm,
     extractable: boolean,
-    keyUsages: string[]
+    keyUsages: string[],
   ): Promise<CryptoKey>;
   timingSafeEqual(
     a: ArrayBuffer | ArrayBufferView,
-    b: ArrayBuffer | ArrayBufferView
+    b: ArrayBuffer | ArrayBufferView,
   ): boolean;
 }
 declare abstract class CryptoKey {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/type) */
   readonly type: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/extractable) */
   readonly extractable: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/algorithm) */
   readonly algorithm:
     | CryptoKeyKeyAlgorithm
     | CryptoKeyAesKeyAlgorithm
@@ -788,6 +1004,7 @@ declare abstract class CryptoKey {
     | CryptoKeyRsaKeyAlgorithm
     | CryptoKeyEllipticKeyAlgorithm
     | CryptoKeyArbitraryKeyAlgorithm;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CryptoKey/usages) */
   readonly usages: string[];
 }
 declare interface CryptoKeyPair {
@@ -896,9 +1113,24 @@ declare class DigestStream extends WritableStream<
 }
 declare class TextDecoder {
   constructor(decoder?: string, options?: TextDecoderConstructorOptions);
+  /**
+   * Returns the result of running encoding's decoder. The method can be invoked zero or more times with options's stream set to true, and then once without options's stream (or set to false), to process a fragmented input. If the invocation without options's stream (or set to false) has no input, it's clearest to omit both arguments.
+   *
+   * ```
+   * var string = "", decoder = new TextDecoder(encoding), buffer;
+   * while(buffer = next_chunk()) {
+   *   string += decoder.decode(buffer, {stream:true});
+   * }
+   * string += decoder.decode(); // end-of-queue
+   * ```
+   *
+   * If the error mode is "fatal" and encoding's decoder returns error, throws a TypeError.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextDecoder/decode)
+   */
   decode(
     input?: ArrayBuffer | ArrayBufferView,
-    options?: TextDecoderDecodeOptions
+    options?: TextDecoderDecodeOptions,
   ): string;
   readonly encoding: string;
   readonly fatal: boolean;
@@ -906,10 +1138,20 @@ declare class TextDecoder {
 }
 declare class TextEncoder {
   constructor();
+  /**
+   * Returns the result of running UTF-8's encoder.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder/encode)
+   */
   encode(input?: string): Uint8Array;
+  /**
+   * Runs the UTF-8 encoder on source, stores the result of that operation into destination, and returns the progress made as an object wherein read is the number of converted code units of source and written is the number of bytes modified in destination.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/TextEncoder/encodeInto)
+   */
   encodeInto(
     input: string,
-    buffer: ArrayBuffer | ArrayBufferView
+    buffer: ArrayBuffer | ArrayBufferView,
   ): TextEncoderEncodeIntoResult;
   readonly encoding: string;
 }
@@ -934,17 +1176,20 @@ declare class FormData {
   has(name: string): boolean;
   set(name: string, value: string): void;
   set(name: string, value: Blob, filename?: string): void;
+  /** Returns an array of key, value pairs for every entry in the list. */
   entries(): IterableIterator<[key: string, value: File | string]>;
+  /** Returns a list of keys in the list. */
   keys(): IterableIterator<string>;
+  /** Returns a list of values in the list. */
   values(): IterableIterator<File | string>;
   forEach<This = unknown>(
     callback: (
       this: This,
       value: File | string,
       key: string,
-      parent: FormData
+      parent: FormData,
     ) => void,
-    thisArg?: This
+    thisArg?: This,
   ): void;
   [Symbol.iterator](): IterableIterator<[key: string, value: File | string]>;
 }
@@ -955,7 +1200,7 @@ declare class HTMLRewriter {
   constructor();
   on(
     selector: string,
-    handlers: HTMLRewriterElementContentHandlers
+    handlers: HTMLRewriterElementContentHandlers,
   ): HTMLRewriter;
   onDocument(handlers: HTMLRewriterDocumentContentHandlers): HTMLRewriter;
   transform(response: Response): Response;
@@ -1022,7 +1267,9 @@ declare interface DocumentEnd {
   append(content: string, options?: ContentOptions): DocumentEnd;
 }
 declare abstract class FetchEvent extends ExtendableEvent {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/request) */
   readonly request: Request;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/FetchEvent/respondWith) */
   respondWith(promise: Response | Promise<Response>): void;
   passThroughOnException(): void;
 }
@@ -1040,10 +1287,13 @@ declare class Headers {
   delete(name: string): void;
   forEach<This = unknown>(
     callback: (this: This, value: string, key: string, parent: Headers) => void,
-    thisArg?: This
+    thisArg?: This,
   ): void;
+  /** Returns an iterator allowing to go through all key/value pairs contained in this object. */
   entries(): IterableIterator<[key: string, value: 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>;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
 }
@@ -1066,14 +1316,23 @@ declare abstract class Body {
 }
 declare class Response extends Body {
   constructor(body?: BodyInit | null, init?: ResponseInit);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirect_static) */
   static redirect(url: string, status?: number): Response;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/json_static) */
   static json(any: any, maybeInit?: ResponseInit | Response): Response;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/clone) */
   clone(): Response;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/status) */
   readonly status: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/statusText) */
   readonly statusText: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/headers) */
   readonly headers: Headers;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/ok) */
   readonly ok: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/redirected) */
   readonly redirected: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Response/url) */
   readonly url: string;
   readonly webSocket: WebSocket | null;
   readonly cf?: any;
@@ -1088,29 +1347,58 @@ declare interface ResponseInit {
 }
 declare type RequestInfo<
   CfHostMetadata = unknown,
-  Cf = CfProperties<CfHostMetadata>
+  Cf = CfProperties<CfHostMetadata>,
 > = Request<CfHostMetadata, Cf> | string | URL;
 declare class Request<
   CfHostMetadata = unknown,
-  Cf = CfProperties<CfHostMetadata>
+  Cf = CfProperties<CfHostMetadata>,
 > extends Body {
   constructor(input: RequestInfo<CfProperties>, init?: RequestInit<Cf>);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/clone) */
   clone(): Request<CfHostMetadata, Cf>;
-  /** Returns request's HTTP method, which is "GET" by default. */
+  /**
+   * Returns request's HTTP method, which is "GET" by default.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/method)
+   */
   readonly method: string;
-  /** Returns the URL of request as a string. */
+  /**
+   * Returns the URL of request as a string.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/url)
+   */
   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. */
+  /**
+   * 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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/headers)
+   */
   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. */
+  /**
+   * 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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/redirect)
+   */
   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. */
+  /**
+   * Returns the signal associated with request, which is an AbortSignal object indicating whether or not request has been aborted, and its abort event handler.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/signal)
+   */
   readonly signal: AbortSignal;
   readonly cf?: Cf;
-  /** Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI] */
+  /**
+   * Returns request's subresource integrity metadata, which is a cryptographic hash of the resource being fetched. Its value consists of multiple hashes separated by whitespace. [SRI]
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/integrity)
+   */
   readonly integrity: string;
-  /** Returns a boolean indicating whether or not request can outlive the global in which it was created. */
+  /**
+   * Returns a boolean indicating whether or not request can outlive the global in which it was created.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Request/keepalive)
+   */
   readonly keepalive: boolean;
 }
 declare interface RequestInit<Cf = CfProperties> {
@@ -1129,10 +1417,18 @@ declare interface RequestInit<Cf = CfProperties> {
   /** An AbortSignal to set request's signal. */
   signal?: AbortSignal | null;
 }
-declare abstract class Fetcher {
+declare type Service<
+  T extends Rpc.WorkerEntrypointBranded | undefined = undefined,
+> = Fetcher<T>;
+declare type Fetcher<
+  T extends Rpc.EntrypointBranded | undefined = undefined,
+  Reserved extends string = never,
+> = (T extends Rpc.EntrypointBranded
+  ? Rpc.Provider<T, Reserved | "fetch" | "connect">
+  : unknown) & {
   fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
   connect(address: SocketAddress | string, options?: SocketOptions): Socket;
-}
+};
 declare interface FetcherPutOptions {
   expiration?: number;
   expirationTtl?: number;
@@ -1157,74 +1453,74 @@ declare type KVNamespaceListResult<Metadata, Key extends string = string> =
 declare interface KVNamespace<Key extends string = string> {
   get(
     key: Key,
-    options?: Partial<KVNamespaceGetOptions<undefined>>
+    options?: Partial<KVNamespaceGetOptions<undefined>>,
   ): Promise<string | null>;
   get(key: Key, type: "text"): Promise<string | null>;
   get<ExpectedValue = unknown>(
     key: Key,
-    type: "json"
+    type: "json",
   ): Promise<ExpectedValue | null>;
   get(key: Key, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
   get(key: Key, type: "stream"): Promise<ReadableStream | null>;
   get(
     key: Key,
-    options?: KVNamespaceGetOptions<"text">
+    options?: KVNamespaceGetOptions<"text">,
   ): Promise<string | null>;
   get<ExpectedValue = unknown>(
     key: Key,
-    options?: KVNamespaceGetOptions<"json">
+    options?: KVNamespaceGetOptions<"json">,
   ): Promise<ExpectedValue | null>;
   get(
     key: Key,
-    options?: KVNamespaceGetOptions<"arrayBuffer">
+    options?: KVNamespaceGetOptions<"arrayBuffer">,
   ): Promise<ArrayBuffer | null>;
   get(
     key: Key,
-    options?: KVNamespaceGetOptions<"stream">
+    options?: KVNamespaceGetOptions<"stream">,
   ): Promise<ReadableStream | null>;
   list<Metadata = unknown>(
-    options?: KVNamespaceListOptions
+    options?: KVNamespaceListOptions,
   ): Promise<KVNamespaceListResult<Metadata, Key>>;
   put(
     key: Key,
     value: string | ArrayBuffer | ArrayBufferView | ReadableStream,
-    options?: KVNamespacePutOptions
+    options?: KVNamespacePutOptions,
   ): Promise<void>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    options?: Partial<KVNamespaceGetOptions<undefined>>
+    options?: Partial<KVNamespaceGetOptions<undefined>>,
   ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    type: "text"
+    type: "text",
   ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
     key: Key,
-    type: "json"
+    type: "json",
   ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    type: "arrayBuffer"
+    type: "arrayBuffer",
   ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    type: "stream"
+    type: "stream",
   ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    options: KVNamespaceGetOptions<"text">
+    options: KVNamespaceGetOptions<"text">,
   ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
   getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
     key: Key,
-    options: KVNamespaceGetOptions<"json">
+    options: KVNamespaceGetOptions<"json">,
   ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    options: KVNamespaceGetOptions<"arrayBuffer">
+    options: KVNamespaceGetOptions<"arrayBuffer">,
   ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
   getWithMetadata<Metadata = unknown>(
     key: Key,
-    options: KVNamespaceGetOptions<"stream">
+    options: KVNamespaceGetOptions<"stream">,
   ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
   delete(key: Key): Promise<void>;
 }
@@ -1252,7 +1548,7 @@ declare interface Queue<Body = unknown> {
   send(message: Body, options?: QueueSendOptions): Promise<void>;
   sendBatch(
     messages: Iterable<MessageSendRequest<Body>>,
-    options?: QueueSendBatchOptions
+    options?: QueueSendBatchOptions,
   ): Promise<void>;
 }
 declare interface QueueSendOptions {
@@ -1274,6 +1570,7 @@ declare interface Message<Body = unknown> {
   readonly id: string;
   readonly timestamp: Date;
   readonly body: Body;
+  readonly attempts: number;
   retry(options?: QueueRetryOptions): void;
   ack(): void;
 }
@@ -1309,7 +1606,7 @@ declare abstract class R2Bucket {
     key: string,
     options: R2GetOptions & {
       onlyIf: R2Conditional | Headers;
-    }
+    },
   ): Promise<R2ObjectBody | R2Object | null>;
   get(key: string, options?: R2GetOptions): Promise<R2ObjectBody | null>;
   put(
@@ -1323,7 +1620,7 @@ declare abstract class R2Bucket {
       | Blob,
     options?: R2PutOptions & {
       onlyIf: R2Conditional | Headers;
-    }
+    },
   ): Promise<R2Object | null>;
   put(
     key: string,
@@ -1334,11 +1631,11 @@ declare abstract class R2Bucket {
       | string
       | null
       | Blob,
-    options?: R2PutOptions
+    options?: R2PutOptions,
   ): Promise<R2Object>;
   createMultipartUpload(
     key: string,
-    options?: R2MultipartOptions
+    options?: R2MultipartOptions,
   ): Promise<R2MultipartUpload>;
   resumeMultipartUpload(key: string, uploadId: string): R2MultipartUpload;
   delete(keys: string | string[]): Promise<void>;
@@ -1349,7 +1646,7 @@ declare interface R2MultipartUpload {
   readonly uploadId: string;
   uploadPart(
     partNumber: number,
-    value: ReadableStream | (ArrayBuffer | ArrayBufferView) | string | Blob
+    value: ReadableStream | (ArrayBuffer | ArrayBufferView) | string | Blob,
   ): Promise<R2UploadedPart>;
   abort(): Promise<void>;
   complete(uploadedParts: R2UploadedPart[]): Promise<R2Object>;
@@ -1470,7 +1767,7 @@ declare interface UnderlyingSink<W = any> {
   start?: (controller: WritableStreamDefaultController) => void | Promise<void>;
   write?: (
     chunk: W,
-    controller: WritableStreamDefaultController
+    controller: WritableStreamDefaultController,
   ) => void | Promise<void>;
   abort?: (reason: any) => void | Promise<void>;
   close?: () => void | Promise<void>;
@@ -1485,10 +1782,10 @@ declare interface UnderlyingByteSource {
 declare interface UnderlyingSource<R = any> {
   type?: "" | undefined;
   start?: (
-    controller: ReadableStreamDefaultController<R>
+    controller: ReadableStreamDefaultController<R>,
   ) => void | Promise<void>;
   pull?: (
-    controller: ReadableStreamDefaultController<R>
+    controller: ReadableStreamDefaultController<R>,
   ) => void | Promise<void>;
   cancel?: (reason: any) => void | Promise<void>;
   expectedLength?: number | bigint;
@@ -1497,14 +1794,14 @@ declare interface Transformer<I = any, O = any> {
   readableType?: string;
   writableType?: string;
   start?: (
-    controller: TransformStreamDefaultController<O>
+    controller: TransformStreamDefaultController<O>,
   ) => void | Promise<void>;
   transform?: (
     chunk: I,
-    controller: TransformStreamDefaultController<O>
+    controller: TransformStreamDefaultController<O>,
   ) => void | Promise<void>;
   flush?: (
-    controller: TransformStreamDefaultController<O>
+    controller: TransformStreamDefaultController<O>,
   ) => void | Promise<void>;
   cancel?: (reason: any) => void | Promise<void>;
   expectedLength?: number;
@@ -1541,91 +1838,137 @@ declare type ReadableStreamReadResult<R = any> =
       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. */
+/**
+ * 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.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream)
+ */
 declare interface ReadableStream<R = any> {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/locked) */
   readonly locked: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/cancel) */
   cancel(reason?: any): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader) */
   getReader(): ReadableStreamDefaultReader<R>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/getReader) */
   getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeThrough) */
   pipeThrough<T>(
     transform: ReadableWritablePair<T, R>,
-    options?: StreamPipeOptions
+    options?: StreamPipeOptions,
   ): ReadableStream<T>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/pipeTo) */
   pipeTo(
     destination: WritableStream<R>,
-    options?: StreamPipeOptions
+    options?: StreamPipeOptions,
   ): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStream/tee) */
   tee(): [ReadableStream<R>, ReadableStream<R>];
   values(options?: ReadableStreamValuesOptions): AsyncIterableIterator<R>;
   [Symbol.asyncIterator](
-    options?: ReadableStreamValuesOptions
+    options?: ReadableStreamValuesOptions,
   ): AsyncIterableIterator<R>;
 }
 declare const ReadableStream: {
   prototype: ReadableStream;
   new (
     underlyingSource: UnderlyingByteSource,
-    strategy?: QueuingStrategy<Uint8Array>
+    strategy?: QueuingStrategy<Uint8Array>,
   ): ReadableStream<Uint8Array>;
   new <R = any>(
     underlyingSource?: UnderlyingSource<R>,
-    strategy?: QueuingStrategy<R>
+    strategy?: QueuingStrategy<R>,
   ): ReadableStream<R>;
 };
 declare class ReadableStreamDefaultReader<R = any> {
   constructor(stream: ReadableStream);
   readonly closed: Promise<void>;
   cancel(reason?: any): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/read) */
   read(): Promise<ReadableStreamReadResult<R>>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultReader/releaseLock) */
   releaseLock(): void;
 }
 declare class ReadableStreamBYOBReader {
   constructor(stream: ReadableStream);
   readonly closed: Promise<void>;
   cancel(reason?: any): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/read) */
   read<T extends ArrayBufferView>(
-    view: T
+    view: T,
   ): Promise<ReadableStreamReadResult<T>>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBReader/releaseLock) */
   releaseLock(): void;
   readAtLeast<T extends ArrayBufferView>(
     minElements: number,
-    view: T
+    view: T,
   ): Promise<ReadableStreamReadResult<T>>;
 }
 declare interface ReadableStreamBYOBReaderReadableStreamBYOBReaderReadOptions {
   min?: number;
 }
 declare interface ReadableStreamGetReaderOptions {
+  /**
+   * Creates a ReadableStreamBYOBReader and locks the stream to the new reader.
+   *
+   * This call behaves the same way as the no-argument variant, except that it only works on readable byte streams, i.e. streams which were constructed specifically with the ability to handle "bring your own buffer" reading. The returned BYOB reader provides the ability to directly read individual chunks from the stream via its read() method, into developer-supplied buffers, allowing more precise control over allocation.
+   */
   mode: "byob";
 }
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest) */
 declare interface ReadableStreamBYOBRequest {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/view) */
   readonly view: Uint8Array | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respond) */
   respond(bytesWritten: number): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamBYOBRequest/respondWithNewView) */
   respondWithNewView(view: ArrayBuffer | ArrayBufferView): void;
   readonly atLeast: number | null;
 }
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController) */
 declare interface ReadableStreamDefaultController<R = any> {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/desiredSize) */
   readonly desiredSize: number | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/close) */
   close(): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/enqueue) */
   enqueue(chunk?: R): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableStreamDefaultController/error) */
   error(reason: any): void;
 }
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController) */
 declare interface ReadableByteStreamController {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/byobRequest) */
   readonly byobRequest: ReadableStreamBYOBRequest | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/desiredSize) */
   readonly desiredSize: number | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/close) */
   close(): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/enqueue) */
   enqueue(chunk: ArrayBuffer | ArrayBufferView): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ReadableByteStreamController/error) */
   error(reason: any): void;
 }
-/** 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. */
+/**
+ * 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.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController)
+ */
 declare interface WritableStreamDefaultController {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/signal) */
   readonly signal: AbortSignal;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultController/error) */
   error(reason?: any): void;
 }
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController) */
 declare interface TransformStreamDefaultController<O = any> {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/desiredSize) */
   get desiredSize(): number | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/enqueue) */
   enqueue(chunk?: O): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/error) */
   error(reason: any): void;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStreamDefaultController/terminate) */
   terminate(): void;
 }
 declare interface ReadableWritablePair<R = any, W = any> {
@@ -1640,36 +1983,49 @@ declare interface ReadableWritablePair<R = any, W = any> {
 declare class WritableStream<W = any> {
   constructor(
     underlyingSink?: UnderlyingSink,
-    queuingStrategy?: QueuingStrategy
+    queuingStrategy?: QueuingStrategy,
   );
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/locked) */
   readonly locked: boolean;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/abort) */
   abort(reason?: any): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/close) */
   close(): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStream/getWriter) */
   getWriter(): WritableStreamDefaultWriter<W>;
 }
 declare class WritableStreamDefaultWriter<W = any> {
   constructor(stream: WritableStream);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/closed) */
   readonly closed: Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/ready) */
   readonly ready: Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/desiredSize) */
   readonly desiredSize: number | null;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/abort) */
   abort(reason?: any): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/close) */
   close(): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/write) */
   write(chunk?: W): Promise<void>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/WritableStreamDefaultWriter/releaseLock) */
   releaseLock(): void;
 }
 declare class TransformStream<I = any, O = any> {
   constructor(
     transformer?: Transformer<I, O>,
     writableStrategy?: QueuingStrategy<I>,
-    readableStrategy?: QueuingStrategy<O>
+    readableStrategy?: QueuingStrategy<O>,
   );
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/readable) */
   readonly readable: ReadableStream<O>;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/TransformStream/writable) */
   readonly writable: WritableStream<I>;
 }
 declare class FixedLengthStream extends IdentityTransformStream {
   constructor(
     expectedLength: number | bigint,
-    queuingStrategy?: IdentityTransformStreamQueuingStrategy
+    queuingStrategy?: IdentityTransformStreamQueuingStrategy,
   );
 }
 declare class IdentityTransformStream extends TransformStream<
@@ -1712,12 +2068,16 @@ declare class ByteLengthQueuingStrategy
   implements QueuingStrategy<ArrayBufferView>
 {
   constructor(init: QueuingStrategyInit);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/highWaterMark) */
   get highWaterMark(): number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ByteLengthQueuingStrategy/size) */
   get size(): (chunk?: any) => number;
 }
 declare class CountQueuingStrategy implements QueuingStrategy {
   constructor(init: QueuingStrategyInit);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/highWaterMark) */
   get highWaterMark(): number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/CountQueuingStrategy/size) */
   get size(): (chunk?: any) => number;
 }
 declare interface QueuingStrategyInit {
@@ -1741,6 +2101,7 @@ declare interface TraceItem {
   readonly event:
     | (
         | TraceItemFetchEventInfo
+        | TraceItemJsRpcEventInfo
         | TraceItemScheduledEventInfo
         | TraceItemAlarmEventInfo
         | TraceItemQueueEventInfo
@@ -1755,6 +2116,7 @@ declare interface TraceItem {
   readonly exceptions: TraceException[];
   readonly diagnosticsChannelEvents: TraceDiagnosticChannelEvent[];
   readonly scriptName: string | null;
+  readonly entrypoint?: string;
   readonly scriptVersion?: ScriptVersion;
   readonly dispatchNamespace?: string;
   readonly scriptTags?: string[];
@@ -1797,6 +2159,9 @@ declare interface TraceItemFetchEventInfoRequest {
 declare interface TraceItemFetchEventInfoResponse {
   readonly status: number;
 }
+declare interface TraceItemJsRpcEventInfo {
+  readonly rpcMethod: string;
+}
 declare interface TraceItemHibernatableWebSocketEventInfo {
   readonly getWebSocketEvent:
     | TraceItemHibernatableWebSocketEventInfoMessage
@@ -1823,6 +2188,7 @@ declare interface TraceException {
   readonly timestamp: number;
   readonly message: string;
   readonly name: string;
+  readonly stack?: string;
 }
 declare interface TraceDiagnosticChannelEvent {
   readonly timestamp: number;
@@ -1838,19 +2204,32 @@ declare interface UnsafeTraceMetrics {
 }
 declare class URL {
   constructor(url: string | URL, base?: string | URL);
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/href) */
   href: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/origin) */
   readonly origin: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/protocol) */
   protocol: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/username) */
   username: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/password) */
   password: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/host) */
   host: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hostname) */
   hostname: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/port) */
   port: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/pathname) */
   pathname: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/search) */
   search: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/searchParams) */
   readonly searchParams: URLSearchParams;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/hash) */
   hash: string;
   toString(): string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/URL/toJSON) */
   toJSON(): string;
 }
 declare class URLSearchParams {
@@ -1859,7 +2238,7 @@ declare class URLSearchParams {
       | URLSearchParams
       | string
       | Record<string, string>
-      | [key: string, value: string][]
+      | [key: string, value: string][],
   );
   get size(): number;
   append(name: string, value: string): void;
@@ -1869,17 +2248,20 @@ declare class URLSearchParams {
   has(name: string): boolean;
   set(name: string, value: string): void;
   sort(): void;
+  /** Returns an array of key, value pairs for every entry in the search params. */
   entries(): IterableIterator<[key: string, value: 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>;
   forEach<This = unknown>(
     callback: (
       this: This,
       value: string,
       key: string,
-      parent: URLSearchParams
+      parent: URLSearchParams,
     ) => void,
-    thisArg?: This
+    thisArg?: This,
   ): void;
   toString(): string;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
@@ -1888,7 +2270,7 @@ declare class URLPattern {
   constructor(
     input?: string | URLPatternURLPatternInit,
     baseURL?: string,
-    patternOptions?: URLPatternURLPatternOptions
+    patternOptions?: URLPatternURLPatternOptions,
   );
   get protocol(): string;
   get username(): string;
@@ -1901,7 +2283,7 @@ declare class URLPattern {
   test(input?: string | URLPatternURLPatternInit, baseURL?: string): boolean;
   exec(
     input?: string | URLPatternURLPatternInit,
-    baseURL?: string
+    baseURL?: string,
   ): URLPatternURLPatternResult | null;
 }
 declare interface URLPatternURLPatternInit {
@@ -1935,11 +2317,23 @@ declare interface URLPatternURLPatternOptions {
 }
 declare class CloseEvent extends Event {
   constructor(type: string, initializer?: CloseEventInit);
-  /** Returns the WebSocket connection close code provided by the server. */
+  /**
+   * Returns the WebSocket connection close code provided by the server.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/code)
+   */
   readonly code: number;
-  /** Returns the WebSocket connection close reason provided by the server. */
+  /**
+   * Returns the WebSocket connection close reason provided by the server.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/reason)
+   */
   readonly reason: string;
-  /** Returns true if the connection closed cleanly; false otherwise. */
+  /**
+   * Returns true if the connection closed cleanly; false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CloseEvent/wasClean)
+   */
   readonly wasClean: boolean;
 }
 declare interface CloseEventInit {
@@ -1954,12 +2348,21 @@ declare class MessageEvent extends Event {
 declare interface MessageEventInit {
   data: ArrayBuffer | string;
 }
-/** Events providing information related to errors in scripts or in files. */
+/**
+ * Events providing information related to errors in scripts or in files.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent)
+ */
 declare interface ErrorEvent extends Event {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/filename) */
   readonly filename: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/message) */
   readonly message: string;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/lineno) */
   readonly lineno: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/colno) */
   readonly colno: number;
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/ErrorEvent/error) */
   readonly error: any;
 }
 declare type WebSocketEventMap = {
@@ -1971,7 +2374,17 @@ declare type WebSocketEventMap = {
 declare class WebSocket extends EventTarget<WebSocketEventMap> {
   constructor(url: string, protocols?: string[] | string);
   accept(): void;
+  /**
+   * Transmits data using the WebSocket connection. data can be a string, a Blob, an ArrayBuffer, or an ArrayBufferView.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/send)
+   */
   send(message: (ArrayBuffer | ArrayBufferView) | string): void;
+  /**
+   * Closes the WebSocket connection, optionally using code as the the WebSocket connection close code and reason as the the WebSocket connection close reason.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/close)
+   */
   close(code?: number, reason?: string): void;
   serializeAttachment(attachment: any): void;
   deserializeAttachment(): any | null;
@@ -1983,13 +2396,29 @@ declare class WebSocket extends EventTarget<WebSocketEventMap> {
   static readonly CLOSING: number;
   static readonly READY_STATE_CLOSED: number;
   static readonly CLOSED: number;
-  /** Returns the state of the WebSocket object's connection. It can have the values described below. */
+  /**
+   * Returns the state of the WebSocket object's connection. It can have the values described below.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/readyState)
+   */
   readonly readyState: number;
-  /** Returns the URL that was used to establish the WebSocket connection. */
+  /**
+   * Returns the URL that was used to establish the WebSocket connection.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/url)
+   */
   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. */
+  /**
+   * 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.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/protocol)
+   */
   readonly protocol: string | null;
-  /** Returns the extensions selected by the server, if any. */
+  /**
+   * Returns the extensions selected by the server, if any.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/WebSocket/extensions)
+   */
   readonly extensions: string | null;
 }
 declare const WebSocketPair: {
@@ -2030,24 +2459,24 @@ declare abstract class gpuGPUAdapter {
 declare interface gpuGPUDevice extends EventTarget {
   createBuffer(param1: gpuGPUBufferDescriptor): gpuGPUBuffer;
   createBindGroupLayout(
-    descriptor: gpuGPUBindGroupLayoutDescriptor
+    descriptor: gpuGPUBindGroupLayoutDescriptor,
   ): gpuGPUBindGroupLayout;
   createBindGroup(descriptor: gpuGPUBindGroupDescriptor): gpuGPUBindGroup;
   createSampler(descriptor: gpuGPUSamplerDescriptor): gpuGPUSampler;
   createShaderModule(
-    descriptor: gpuGPUShaderModuleDescriptor
+    descriptor: gpuGPUShaderModuleDescriptor,
   ): gpuGPUShaderModule;
   createPipelineLayout(
-    descriptor: gpuGPUPipelineLayoutDescriptor
+    descriptor: gpuGPUPipelineLayoutDescriptor,
   ): gpuGPUPipelineLayout;
   createComputePipeline(
-    descriptor: gpuGPUComputePipelineDescriptor
+    descriptor: gpuGPUComputePipelineDescriptor,
   ): gpuGPUComputePipeline;
   createRenderPipeline(
-    descriptor: gpuGPURenderPipelineDescriptor
+    descriptor: gpuGPURenderPipelineDescriptor,
   ): gpuGPURenderPipeline;
   createCommandEncoder(
-    descriptor?: gpuGPUCommandEncoderDescriptor
+    descriptor?: gpuGPUCommandEncoderDescriptor,
   ): gpuGPUCommandEncoder;
   createTexture(param1: gpuGPUTextureDescriptor): gpuGPUTexture;
   destroy(): void;
@@ -2093,7 +2522,7 @@ declare interface gpuGPUBuffer {
   mapAsync(
     offset: number,
     size?: number | bigint,
-    param3?: number | bigint
+    param3?: number | bigint,
   ): Promise<void>;
   get size(): number | bigint;
   get usage(): number;
@@ -2192,38 +2621,38 @@ declare interface gpuGPUProgrammableStage {
 declare interface gpuGPUCommandEncoder {
   get label(): string;
   beginComputePass(
-    descriptor?: gpuGPUComputePassDescriptor
+    descriptor?: gpuGPUComputePassDescriptor,
   ): gpuGPUComputePassEncoder;
   beginRenderPass(
-    descriptor: gpuGPURenderPassDescriptor
+    descriptor: gpuGPURenderPassDescriptor,
   ): gpuGPURenderPassEncoder;
   copyBufferToBuffer(
     source: gpuGPUBuffer,
     sourceOffset: number | bigint,
     destination: gpuGPUBuffer,
     destinationOffset: number | bigint,
-    size: number | bigint
+    size: number | bigint,
   ): void;
   finish(param0?: gpuGPUCommandBufferDescriptor): gpuGPUCommandBuffer;
   copyTextureToBuffer(
     source: gpuGPUImageCopyTexture,
     destination: gpuGPUImageCopyBuffer,
-    copySize: Iterable<number> | gpuGPUExtent3DDict
+    copySize: Iterable<number> | gpuGPUExtent3DDict,
   ): void;
   copyBufferToTexture(
     source: gpuGPUImageCopyBuffer,
     destination: gpuGPUImageCopyTexture,
-    copySize: Iterable<number> | gpuGPUExtent3DDict
+    copySize: Iterable<number> | gpuGPUExtent3DDict,
   ): void;
   copyTextureToTexture(
     source: gpuGPUImageCopyTexture,
     destination: gpuGPUImageCopyTexture,
-    copySize: Iterable<number> | gpuGPUExtent3DDict
+    copySize: Iterable<number> | gpuGPUExtent3DDict,
   ): void;
   clearBuffer(
     buffer: gpuGPUBuffer,
     offset?: number | bigint,
-    size?: number | bigint
+    size?: number | bigint,
   ): void;
 }
 declare interface gpuGPUCommandEncoderDescriptor {
@@ -2234,12 +2663,12 @@ declare interface gpuGPUComputePassEncoder {
   setBindGroup(
     index: number,
     bindGroup: gpuGPUBindGroup | null,
-    dynamicOffsets?: Iterable<number>
+    dynamicOffsets?: Iterable<number>,
   ): void;
   dispatchWorkgroups(
     workgroupCountX: number,
     workgroupCountY?: number,
-    workgroupCountZ?: number
+    workgroupCountZ?: number,
   ): void;
   end(): void;
 }
@@ -2267,7 +2696,7 @@ declare interface gpuGPUQueue {
     bufferOffset: number | bigint,
     data: ArrayBuffer | ArrayBufferView,
     dataOffset?: number | bigint,
-    size?: number | bigint
+    size?: number | bigint,
   ): void;
 }
 declare abstract class gpuGPUMapMode {
@@ -2471,7 +2900,7 @@ declare interface gpuGPURenderPassEncoder {
     vertexCount: number,
     instanceCount?: number,
     firstVertex?: number,
-    firstInstance?: number
+    firstInstance?: number,
   ): void;
   end(): void;
 }
@@ -2969,7 +3398,7 @@ declare interface IncomingRequestCfPropertiesBotManagementEnterprise
   };
 }
 declare interface IncomingRequestCfPropertiesCloudflareForSaaSEnterprise<
-  HostMetadata
+  HostMetadata,
 > {
   /**
    * Custom metadata set per-host in [Cloudflare for SaaS](https://developers.cloudflare.com/cloudflare-for-platforms/cloudflare-for-saas/).
@@ -3539,6 +3968,13 @@ declare abstract class D1PreparedStatement {
   }): Promise<[string[], ...T[]]>;
   raw<T = unknown[]>(options?: { columnNames?: false }): Promise<T[]>;
 }
+// `Disposable` was added to TypeScript's standard lib types in version 5.2.
+// To support older TypeScript versions, define an empty `Disposable` interface.
+// Users won't be able to use `using`/`Symbol.dispose` without upgrading to 5.2,
+// but this will ensure type checking on older versions still passes.
+// TypeScript's interface merging will ensure our empty interface is effectively
+// ignored when `Disposable` is included in the standard lib.
+declare interface Disposable {}
 /**
  * An email message that can be sent from a Worker.
  */
@@ -3594,7 +4030,7 @@ declare abstract class EmailEvent extends ExtendableEvent {
 declare type EmailExportedHandler<Env = unknown> = (
   message: ForwardableEmailMessage,
   env: Env,
-  ctx: ExecutionContext
+  ctx: ExecutionContext,
 ) => void | Promise<void>;
 declare module "cloudflare:email" {
   let _EmailMessage: {
@@ -3668,7 +4104,7 @@ declare type EventContext<Env, P extends string, Data> = {
 declare type PagesFunction<
   Env = unknown,
   Params extends string = any,
-  Data extends Record<string, unknown> = Record<string, unknown>
+  Data extends Record<string, unknown> = Record<string, unknown>,
 > = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;
 declare type EventPluginContext<Env, P extends string, Data, PluginArgs> = {
   request: Request<unknown, IncomingRequestCfProperties<unknown>>;
@@ -3689,9 +4125,9 @@ declare type PagesPluginFunction<
   Env = unknown,
   Params extends string = any,
   Data extends Record<string, unknown> = Record<string, unknown>,
-  PluginArgs = unknown
+  PluginArgs = unknown,
 > = (
-  context: EventPluginContext<Env, Params, Data, PluginArgs>
+  context: EventPluginContext<Env, Params, Data, PluginArgs>,
 ) => Response | Promise<Response>;
 declare module "assets:*" {
   export const onRequest: PagesFunction;
@@ -3730,10 +4166,204 @@ declare interface JsonWebKeyWithKid extends JsonWebKey {
   // Key Identifier of the JWK
   readonly kid: string;
 }
+// Namespace for RPC utility types. Unfortunately, we can't use a `module` here as these types need
+// to referenced by `Fetcher`. This is included in the "importable" version of the types which
+// strips all `module` blocks.
+declare namespace Rpc {
+  // Branded types for identifying `WorkerEntrypoint`/`DurableObject`/`Target`s.
+  // TypeScript uses *structural* typing meaning anything with the same shape as type `T` is a `T`.
+  // For the classes exported by `cloudflare:workers` we want *nominal* typing (i.e. we only want to
+  // accept `WorkerEntrypoint` from `cloudflare:workers`, not any other class with the same shape)
+  export const __RPC_STUB_BRAND: unique symbol;
+  export const __RPC_TARGET_BRAND: unique symbol;
+  export const __WORKER_ENTRYPOINT_BRAND: unique symbol;
+  export const __DURABLE_OBJECT_BRAND: unique symbol;
+  export interface RpcTargetBranded {
+    [__RPC_TARGET_BRAND]: never;
+  }
+  export interface WorkerEntrypointBranded {
+    [__WORKER_ENTRYPOINT_BRAND]: never;
+  }
+  export interface DurableObjectBranded {
+    [__DURABLE_OBJECT_BRAND]: never;
+  }
+  export type EntrypointBranded =
+    | WorkerEntrypointBranded
+    | DurableObjectBranded;
+  // Types that can be used through `Stub`s
+  export type Stubable = RpcTargetBranded | ((...args: any[]) => any);
+  // Types that can be passed over RPC
+  type Serializable =
+    // Structured cloneables
+    | void
+    | undefined
+    | null
+    | boolean
+    | number
+    | bigint
+    | string
+    | TypedArray
+    | ArrayBuffer
+    | DataView
+    | Date
+    | Error
+    | RegExp
+    // Structured cloneable composites
+    | Map<Serializable, Serializable>
+    | Set<Serializable>
+    | ReadonlyArray<Serializable>
+    | {
+        [key: string | number]: Serializable;
+      }
+    // Special types
+    | ReadableStream<Uint8Array>
+    | WritableStream<Uint8Array>
+    | Request
+    | Response
+    | Headers
+    | Stub<Stubable>
+    // Serialized as stubs, see `Stubify`
+    | Stubable;
+  // Base type for all RPC stubs, including common memory management methods.
+  // `T` is used as a marker type for unwrapping `Stub`s later.
+  interface StubBase<T extends Stubable> extends Disposable {
+    [__RPC_STUB_BRAND]: T;
+    dup(): this;
+  }
+  export type Stub<T extends Stubable> = Provider<T> & StubBase<T>;
+  // Recursively rewrite all `Stubable` types with `Stub`s
+  type Stubify<T> = T extends Stubable
+    ? Stub<T>
+    : T extends Map<infer K, infer V>
+      ? Map<Stubify<K>, Stubify<V>>
+      : T extends Set<infer V>
+        ? Set<Stubify<V>>
+        : T extends Array<infer V>
+          ? Array<Stubify<V>>
+          : T extends ReadonlyArray<infer V>
+            ? ReadonlyArray<Stubify<V>>
+            : T extends {
+                  [key: string | number]: unknown;
+                }
+              ? {
+                  [K in keyof T]: Stubify<T[K]>;
+                }
+              : T;
+  // Recursively rewrite all `Stub<T>`s with the corresponding `T`s.
+  // Note we use `StubBase` instead of `Stub` here to avoid circular dependencies:
+  // `Stub` depends on `Provider`, which depends on `Unstubify`, which would depend on `Stub`.
+  type Unstubify<T> =
+    T extends StubBase<infer V>
+      ? V
+      : T extends Map<infer K, infer V>
+        ? Map<Unstubify<K>, Unstubify<V>>
+        : T extends Set<infer V>
+          ? Set<Unstubify<V>>
+          : T extends Array<infer V>
+            ? Array<Unstubify<V>>
+            : T extends ReadonlyArray<infer V>
+              ? ReadonlyArray<Unstubify<V>>
+              : T extends {
+                    [key: string | number]: unknown;
+                  }
+                ? {
+                    [K in keyof T]: Unstubify<T[K]>;
+                  }
+                : T;
+  type UnstubifyAll<A extends any[]> = {
+    [I in keyof A]: Unstubify<A[I]>;
+  };
+  // Utility type for adding `Provider`/`Disposable`s to `object` types only.
+  // Note `unknown & T` is equivalent to `T`.
+  type MaybeProvider<T> = T extends object ? Provider<T> : unknown;
+  type MaybeDisposable<T> = T extends object ? Disposable : unknown;
+  // Type for method return or property on an RPC interface.
+  // - Stubable types are replaced by stubs.
+  // - Serializable types are passed by value, with stubable types replaced by stubs
+  //   and a top-level `Disposer`.
+  // Everything else can't be passed over PRC.
+  // Technically, we use custom thenables here, but they quack like `Promise`s.
+  // Intersecting with `(Maybe)Provider` allows pipelining.
+  type Result<R> = R extends Stubable
+    ? Promise<Stub<R>> & Provider<R>
+    : R extends Serializable
+      ? Promise<Stubify<R> & MaybeDisposable<R>> & MaybeProvider<R>
+      : never;
+  // Type for method or property on an RPC interface.
+  // For methods, unwrap `Stub`s in parameters, and rewrite returns to be `Result`s.
+  // Unwrapping `Stub`s allows calling with `Stubable` arguments.
+  // For properties, rewrite types to be `Result`s.
+  // In each case, unwrap `Promise`s.
+  type MethodOrProperty<V> = V extends (...args: infer P) => infer R
+    ? (...args: UnstubifyAll<P>) => Result<Awaited<R>>
+    : Result<Awaited<V>>;
+  // Type for the callable part of an `Provider` if `T` is callable.
+  // This is intersected with methods/properties.
+  type MaybeCallableProvider<T> = T extends (...args: any[]) => any
+    ? MethodOrProperty<T>
+    : unknown;
+  // Base type for all other types providing RPC-like interfaces.
+  // Rewrites all methods/properties to be `MethodOrProperty`s, while preserving callable types.
+  // `Reserved` names (e.g. stub method names like `dup()`) and symbols can't be accessed over RPC.
+  export type Provider<
+    T extends object,
+    Reserved extends string = never,
+  > = MaybeCallableProvider<T> & {
+    [K in Exclude<
+      keyof T,
+      Reserved | symbol | keyof StubBase<never>
+    >]: MethodOrProperty<T[K]>;
+  };
+}
+declare module "cloudflare:workers" {
+  export type RpcStub<T extends Rpc.Stubable> = Rpc.Stub<T>;
+  export const RpcStub: {
+    new <T extends Rpc.Stubable>(value: T): Rpc.Stub<T>;
+  };
+  export abstract class RpcTarget implements Rpc.RpcTargetBranded {
+    [Rpc.__RPC_TARGET_BRAND]: never;
+  }
+  // `protected` fields don't appear in `keyof`s, so can't be accessed over RPC
+  export abstract class WorkerEntrypoint<Env = unknown>
+    implements Rpc.WorkerEntrypointBranded
+  {
+    [Rpc.__WORKER_ENTRYPOINT_BRAND]: never;
+    protected ctx: ExecutionContext;
+    protected env: Env;
+    constructor(ctx: ExecutionContext, env: Env);
+    fetch?(request: Request): Response | Promise<Response>;
+    tail?(events: TraceItem[]): void | Promise<void>;
+    trace?(traces: TraceItem[]): void | Promise<void>;
+    scheduled?(controller: ScheduledController): void | Promise<void>;
+    queue?(batch: MessageBatch<unknown>): void | Promise<void>;
+    test?(controller: TestController): void | Promise<void>;
+  }
+  export abstract class DurableObject<Env = unknown>
+    implements Rpc.DurableObjectBranded
+  {
+    [Rpc.__DURABLE_OBJECT_BRAND]: never;
+    protected ctx: DurableObjectState;
+    protected env: Env;
+    constructor(ctx: DurableObjectState, env: Env);
+    fetch?(request: Request): Response | Promise<Response>;
+    alarm?(): void | Promise<void>;
+    webSocketMessage?(
+      ws: WebSocket,
+      message: string | ArrayBuffer,
+    ): void | Promise<void>;
+    webSocketClose?(
+      ws: WebSocket,
+      code: number,
+      reason: string,
+      wasClean: boolean,
+    ): void | Promise<void>;
+    webSocketError?(ws: WebSocket, error: unknown): void | Promise<void>;
+  }
+}
 declare module "cloudflare:sockets" {
   function _connect(
     address: string | SocketAddress,
-    options?: SocketOptions
+    options?: SocketOptions,
   ): Socket;
   export { _connect as connect };
 }
@@ -3869,7 +4499,7 @@ declare abstract class VectorizeIndex {
    */
   public query(
     vector: VectorFloatArray | number[],
-    options: VectorizeQueryOptions
+    options: VectorizeQueryOptions,
   ): Promise<VectorizeMatches>;
   /**
    * Insert a list of vectors into the index dataset. If a provided id exists, an error will be thrown.
@@ -3896,6 +4526,16 @@ declare abstract class VectorizeIndex {
    */
   public getByIds(ids: string[]): Promise<VectorizeVector[]>;
 }
+/**
+ * The interface for "version_metadata" binding
+ * providing metadata about the Worker Version using this binding.
+ */
+declare type WorkerVersionMetadata = {
+  /** The ID of the Worker Version using this binding */
+  id: string;
+  /** The tag of the Worker Version using this binding */
+  tag: string;
+};
 declare interface DynamicDispatchLimits {
   /**
    * Limit CPU time in milliseconds.
@@ -3931,6 +4571,6 @@ declare interface DispatchNamespace {
     args?: {
       [key: string]: any;
     },
-    options?: DynamicDispatchOptions
+    options?: DynamicDispatchOptions,
   ): Fetcher;
 }