@cloudflare/workers-types 3.1.0 → 3.3.1

package/index.d.ts

@@ -4,13 +4,16 @@
 declare class AbortController {
   constructor();
   readonly signal: AbortSignal;
-  abort(): void;
+  abort(reason?: any): void;
 }
 
 declare class AbortSignal extends EventTarget {
   constructor();
-  static abort(): AbortSignal;
+  static abort(reason?: any): AbortSignal;
+  static timeout(delay: number): AbortSignal;
   readonly aborted: boolean;
+  readonly reason: any;
+  throwIfAborted(): void;
 }
 
 interface BasicImageTransformations {
@@ -35,10 +38,11 @@ interface BasicImageTransformations {
    *  - cover: Resizes (shrinks or enlarges) to fill the entire area of width
    *    and height. If the image has an aspect ratio different from the ratio
    *    of width and height, it will be cropped to fit.
-   *  - crop: The image will shrunk and cropped to fit within the area
-   *    specified by width and height. The image won’t be enlarged. For images
-   *    smaller than the given dimensions it’s the same as scale-down. For
-   *    images larger than the given dimensions, it’s the same as cover.
+   *  - crop: The image will be shrunk and cropped to fit within the area
+   *    specified by width and height. The image will not be enlarged. For images
+   *    smaller than the given dimensions it's the same as scale-down. For
+   *    images larger than the given dimensions, it's the same as cover.
+   *    See also trim.
    *  - pad: Resizes to the maximum size that fits within the given width and
    *    height, and then fills the remaining area with a background color
    *    (white by default). Use of this mode is not recommended, as the same
@@ -49,7 +53,7 @@ interface BasicImageTransformations {
   /**
    * 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
@@ -58,7 +62,14 @@ interface BasicImageTransformations {
    * preserve as much as possible around a point at 20% of the height of the
    * source image.
    */
-  gravity?: "left" | "right" | "top" | "bottom" | "center" | BasicImageTransformationsGravityCoordinates;
+  gravity?:
+    | "left"
+    | "right"
+    | "top"
+    | "bottom"
+    | "center"
+    | "auto"
+    | BasicImageTransformationsGravityCoordinates;
   /**
    * Background color to add underneath the image. Applies only to images with
    * transparency (such as PNG). Accepts any CSS color (#RRGGBB, rgba(…),
@@ -103,7 +114,13 @@ declare abstract class Body {
   blob(): Promise<Blob>;
 }
 
-declare type BodyInit = ReadableStream | string | ArrayBuffer | Blob | URLSearchParams | FormData;
+declare type BodyInit =
+  | ReadableStream
+  | string
+  | ArrayBuffer
+  | Blob
+  | URLSearchParams
+  | FormData;
 
 /**
  * Back compat for code migrating to older definitions.
@@ -112,8 +129,14 @@ declare type BodyInit = ReadableStream | string | ArrayBuffer | Blob | URLSearch
 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>;
+  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>;
 }
 
@@ -180,7 +203,15 @@ interface ContentOptions {
 
 declare abstract class Crypto {
   readonly subtle: SubtleCrypto;
-  getRandomValues(buffer: ArrayBufferView): ArrayBufferView;
+  getRandomValues<
+    T extends
+      | Int8Array
+      | Uint8Array
+      | Int16Array
+      | Uint16Array
+      | Int32Array
+      | Uint32Array
+  >(buffer: T): T;
   randomUUID(): string;
 }
 
@@ -196,7 +227,14 @@ interface CryptoKeyAesKeyAlgorithm {
   length: number;
 }
 
-declare type CryptoKeyAlgorithmVariant = CryptoKeyKeyAlgorithm | CryptoKeyAesKeyAlgorithm | CryptoKeyHmacKeyAlgorithm | CryptoKeyRsaKeyAlgorithm | CryptoKeyEllipticKeyAlgorithm | CryptoKeyVoprfKeyAlgorithm | CryptoKeyOprfKeyAlgorithm;
+declare type CryptoKeyAlgorithmVariant =
+  | CryptoKeyKeyAlgorithm
+  | CryptoKeyAesKeyAlgorithm
+  | CryptoKeyHmacKeyAlgorithm
+  | CryptoKeyRsaKeyAlgorithm
+  | CryptoKeyEllipticKeyAlgorithm
+  | CryptoKeyVoprfKeyAlgorithm
+  | CryptoKeyOprfKeyAlgorithm;
 
 interface CryptoKeyEllipticKeyAlgorithm {
   name: string;
@@ -266,6 +304,11 @@ declare class DOMException extends Error {
   static readonly DATA_CLONE_ERR: number;
 }
 
+declare class DigestStream extends WritableStream {
+  constructor(algorithm: string | SubtleCryptoHashAlgorithm);
+  readonly digest: Promise<ArrayBuffer>;
+}
+
 interface Doctype {
   readonly name: string | null;
   readonly publicId: string | null;
@@ -280,14 +323,31 @@ 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;
+  newUniqueId(
+    options?: DurableObjectNamespaceNewUniqueIdOptions
+  ): DurableObjectId;
   idFromName(name: string): DurableObjectId;
   idFromString(id: string): DurableObjectId;
   get(id: DurableObjectId): DurableObjectStub;
@@ -297,6 +357,12 @@ interface DurableObjectNamespaceNewUniqueIdOptions {
   jurisdiction?: string;
 }
 
+interface DurableObjectPutOptions {
+  allowConcurrency?: boolean;
+  allowUnconfirmed?: boolean;
+  noCache?: boolean;
+}
+
 interface DurableObjectState {
   waitUntil(promise: Promise<any>): void;
   readonly id: DurableObjectId | string;
@@ -305,37 +371,52 @@ interface DurableObjectState {
 }
 
 interface DurableObjectStorage {
-  get<T = unknown>(key: string, options?: DurableObjectStorageOperationsGetOptions): Promise<T | undefined>;
-  get<T = unknown>(keys: string[], options?: DurableObjectStorageOperationsGetOptions): Promise<Map<string, T>>;
-  list<T = unknown>(options?: DurableObjectStorageOperationsListOptions): Promise<Map<string, T>>;
-  put<T>(key: string, value: T, options?: DurableObjectStorageOperationsPutOptions): Promise<void>;
-  put<T>(entries: Record<string, T>, options?: DurableObjectStorageOperationsPutOptions): Promise<void>;
-  delete(key: string, options?: DurableObjectStorageOperationsPutOptions): Promise<boolean>;
-  delete(keys: string[], options?: DurableObjectStorageOperationsPutOptions): Promise<number>;
-  deleteAll(options?: DurableObjectStorageOperationsPutOptions): Promise<void>;
-  transaction<T>(closure: (txn: DurableObjectTransaction) => Promise<T>): Promise<T>;
-}
-
-interface DurableObjectStorageOperationsGetOptions {
-  allowConcurrency?: boolean;
-  noCache?: boolean;
+  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>;
 }
 
-interface DurableObjectStorageOperationsListOptions {
-  start?: string;
-  end?: string;
-  prefix?: string;
-  reverse?: boolean;
-  limit?: number;
-  allowConcurrency?: boolean;
-  noCache?: boolean;
-}
+/**
+ *
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ */
+declare type DurableObjectStorageOperationsGetOptions = DurableObjectGetOptions;
 
-interface DurableObjectStorageOperationsPutOptions {
-  allowConcurrency?: boolean;
-  allowUnconfirmed?: boolean;
-  noCache?: boolean;
-}
+/**
+ *
+ * @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;
@@ -343,13 +424,25 @@ interface DurableObjectStub extends Fetcher {
 }
 
 interface DurableObjectTransaction {
-  get<T = unknown>(key: string, options?: DurableObjectStorageOperationsGetOptions): Promise<T>;
-  get<T = unknown>(keys: string[], options?: DurableObjectStorageOperationsGetOptions): Promise<Map<string, T>>;
-  list<T = unknown>(options?: DurableObjectStorageOperationsListOptions): Promise<Map<string, T>>;
-  put<T>(key: string, value: T, options?: DurableObjectStorageOperationsPutOptions): Promise<void>;
-  put<T>(entries: Record<string, T>, options?: DurableObjectStorageOperationsPutOptions): Promise<void>;
-  delete(key: string, options?: DurableObjectStorageOperationsPutOptions): Promise<boolean>;
-  delete(keys: string[], options?: DurableObjectStorageOperationsPutOptions): Promise<number>;
+  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;
 }
 
@@ -370,6 +463,14 @@ interface Element {
   remove(): Element;
   removeAndKeepContent(): Element;
   setInnerContent(content: Content, options?: ContentOptions): Element;
+  onEndTag(handler: Function): void;
+}
+
+interface EndTag {
+  name: string;
+  before(content: Content, options?: ContentOptions): EndTag;
+  after(content: Content, options?: ContentOptions): EndTag;
+  remove(): EndTag;
 }
 
 declare class Event {
@@ -402,18 +503,32 @@ interface EventInit {
   composed?: boolean;
 }
 
-declare type EventListener<EventType extends Event = Event> = (event: EventType) => void;
+declare type EventListener<EventType extends Event = Event> = (
+  event: EventType
+) => void;
 
 interface EventListenerObject<EventType extends Event = Event> {
   handleEvent(event: EventType): void;
 }
 
-declare type EventListenerOrEventListenerObject<EventType extends Event = Event> = EventListener<EventType> | EventListenerObject<EventType>;
+declare type EventListenerOrEventListenerObject<
+  EventType extends Event = Event
+> = EventListener<EventType> | EventListenerObject<EventType>;
 
-declare class EventTarget<EventMap extends Record<string, Event> = Record<string, Event>> {
+declare class EventTarget<
+  EventMap extends Record<string, Event> = Record<string, Event>
+> {
   constructor();
-  addEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetAddEventListenerOptions | boolean): void;
-  removeEventListener<Type extends keyof EventMap>(type: Type, handler: EventListenerOrEventListenerObject<EventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
+  addEventListener<Type extends keyof EventMap>(
+    type: Type,
+    handler: EventListenerOrEventListenerObject<EventMap[Type]>,
+    options?: EventTargetAddEventListenerOptions | boolean
+  ): void;
+  removeEventListener<Type extends keyof EventMap>(
+    type: Type,
+    handler: EventListenerOrEventListenerObject<EventMap[Type]>,
+    options?: EventTargetEventListenerOptions | boolean
+  ): void;
   dispatchEvent(event: EventMap[keyof EventMap]): boolean;
 }
 
@@ -438,9 +553,17 @@ interface ExportedHandler<Env = unknown> {
   scheduled?: ExportedHandlerScheduledHandler<Env>;
 }
 
-declare type ExportedHandlerFetchHandler<Env = unknown> = (request: Request, env: Env, ctx: ExecutionContext) => Response | Promise<Response>;
+declare type ExportedHandlerFetchHandler<Env = unknown> = (
+  request: Request,
+  env: Env,
+  ctx: ExecutionContext
+) => Response | Promise<Response>;
 
-declare type ExportedHandlerScheduledHandler<Env = unknown> = (controller: ScheduledController, env: Env, ctx: ExecutionContext) => void | Promise<void>;
+declare type ExportedHandlerScheduledHandler<Env = unknown> = (
+  controller: ScheduledController,
+  env: Env,
+  ctx: ExecutionContext
+) => void | Promise<void>;
 
 declare abstract class FetchEvent extends Event {
   readonly request: Request;
@@ -450,7 +573,10 @@ declare abstract class FetchEvent extends Event {
 }
 
 declare abstract class Fetcher {
-  fetch(requestOrUrl: Request | string, requestInit?: RequestInit | Request): Promise<Response>;
+  fetch(
+    requestOrUrl: Request | string,
+    requestInit?: RequestInit | Request
+  ): Promise<Response>;
 }
 
 declare class File extends Blob {
@@ -478,16 +604,27 @@ declare class FormData {
   has(name: string): boolean;
   set(name: string, value: string): void;
   set(name: string, value: Blob, filename?: string): void;
-  entries(): IterableIterator<([key: string, value: File | string])[]>;
+  entries(): IterableIterator<[key: string, value: File | string][]>;
   keys(): IterableIterator<string>;
   values(): IterableIterator<File | string>;
-  forEach<This = unknown>(callback: (this: This, key: string, value: File | string, parent: FormData) => void, thisArg?: This): void;
-  [Symbol.iterator](): IterableIterator<([key: string, value: File | string])[]>;
+  forEach<This = unknown>(
+    callback: (
+      this: This,
+      key: string,
+      value: File | string,
+      parent: FormData
+    ) => void,
+    thisArg?: This
+  ): void;
+  [Symbol.iterator](): IterableIterator<[key: string, value: File | string][]>;
 }
 
 declare class HTMLRewriter {
   constructor();
-  on(selector: string, handlers: HTMLRewriterElementContentHandlers): HTMLRewriter;
+  on(
+    selector: string,
+    handlers: HTMLRewriterElementContentHandlers
+  ): HTMLRewriter;
   onDocument(handlers: HTMLRewriterDocumentContentHandlers): HTMLRewriter;
   transform(response: Response): Response;
 }
@@ -513,14 +650,20 @@ declare class Headers {
   set(name: string, value: string): void;
   append(name: string, value: string): void;
   delete(name: string): void;
-  forEach<This = unknown>(callback: (this: This, key: string, value: string, parent: Headers) => void, thisArg?: This): void;
+  forEach<This = unknown>(
+    callback: (this: This, key: string, value: string, parent: Headers) => void,
+    thisArg?: This
+  ): void;
   entries(): IterableIterator<[key: string, value: string]>;
   keys(): IterableIterator<string>;
   values(): IterableIterator<string>;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
 }
 
-declare type HeadersInit = Headers | Record<string, string> | ([key: string, value: string])[];
+declare type HeadersInit =
+  | Headers
+  | Record<string, string>
+  | [key: string, value: string][];
 
 /**
  * Back compat for code migrating to older definitions.
@@ -532,7 +675,7 @@ 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.
  */
@@ -618,21 +761,59 @@ interface IncomingRequestCfPropertiesTLSClientAuth {
   certVerified: 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;
+}
+
 /**
  * Workers KV is a global, low-latency, key-value data store. It supports exceptionally high read volumes with low-latency,
  * making it possible to build highly dynamic APIs and websites which respond as quickly as a cached static file would.
  */
-interface KVNamespace {
-  get(key: string, options?: Partial<KVNamespaceGetOptions<undefined>>): Promise<string | null>;
-  get(key: string, type: "text"): Promise<string | null>;
-  get<ExpectedValue = unknown>(key: string, type: "json"): Promise<ExpectedValue | null>;
-  get(key: string, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
-  get(key: string, type: "stream"): Promise<ReadableStream | null>;
-  get(key: string, options: KVNamespaceGetOptions<"text">): Promise<string | null>;
-  get<ExpectedValue = unknown>(key: string, options: KVNamespaceGetOptions<"json">): Promise<ExpectedValue | null>;
-  get(key: string, options: KVNamespaceGetOptions<"arrayBuffer">): Promise<ArrayBuffer | null>;
-  get(key: string, options: KVNamespaceGetOptions<"stream">): Promise<ReadableStream | null>;
-  list<Metadata = unknown>(options?: KVNamespaceListOptions): Promise<KVNamespaceListResult<Metadata>>;
+interface KVNamespace<K extends string = string> {
+  get(
+    key: K,
+    options?: Partial<KVNamespaceGetOptions<undefined>>
+  ): Promise<string | null>;
+  get(key: K, type: "text"): Promise<string | null>;
+  get<ExpectedValue = unknown>(
+    key: K,
+    type: "json"
+  ): Promise<ExpectedValue | null>;
+  get(key: K, type: "arrayBuffer"): Promise<ArrayBuffer | null>;
+  get(key: K, type: "stream"): Promise<ReadableStream | null>;
+  get(key: K, options: KVNamespaceGetOptions<"text">): Promise<string | null>;
+  get<ExpectedValue = unknown>(
+    key: string,
+    options: KVNamespaceGetOptions<"json">
+  ): Promise<ExpectedValue | null>;
+  get(
+    key: K,
+    options: KVNamespaceGetOptions<"arrayBuffer">
+  ): Promise<ArrayBuffer | null>;
+  get(
+    key: K,
+    options: KVNamespaceGetOptions<"stream">
+  ): Promise<ReadableStream | null>;
+  list<Metadata = unknown>(
+    options?: KVNamespaceListOptions
+  ): Promise<KVNamespaceListResult<Metadata>>;
   /**
    * Creates a new key-value pair, or updates the value for a particular key.
    * @param key key to associate with the value. A key cannot be empty, `.` or `..`. All other keys are valid.
@@ -641,16 +822,47 @@ interface KVNamespace {
    * @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>>;
+  put(
+    key: K,
+    value: string | ArrayBuffer | ArrayBufferView | ReadableStream,
+    options?: KVNamespacePutOptions
+  ): Promise<void>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options?: Partial<KVNamespaceGetOptions<undefined>>
+  ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    type: "text"
+  ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
+    key: K,
+    type: "json"
+  ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    type: "arrayBuffer"
+  ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    type: "stream"
+  ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"text">
+  ): Promise<KVNamespaceGetWithMetadataResult<string, Metadata>>;
+  getWithMetadata<ExpectedValue = unknown, Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"json">
+  ): Promise<KVNamespaceGetWithMetadataResult<ExpectedValue, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"arrayBuffer">
+  ): Promise<KVNamespaceGetWithMetadataResult<ArrayBuffer, Metadata>>;
+  getWithMetadata<Metadata = unknown>(
+    key: K,
+    options: KVNamespaceGetOptions<"stream">
+  ): Promise<KVNamespaceGetWithMetadataResult<ReadableStream, Metadata>>;
   delete(name: string): Promise<void>;
 }
 
@@ -723,23 +935,60 @@ interface ReadResult {
   done: boolean;
 }
 
-declare abstract class ReadableStream {
+declare abstract class ReadableByteStreamController {
+  readonly byobRequest: ReadableStreamBYOBRequest | null;
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk: ArrayBufferView): void;
+  error(reason: any): void;
+}
+
+declare class ReadableStream {
+  constructor(underlyingSource?: Object, queuingStrategy?: Object);
   readonly locked: boolean;
   cancel(reason?: any): Promise<void>;
   getReader(options: ReadableStreamGetReaderOptions): ReadableStreamBYOBReader;
   getReader(): ReadableStreamDefaultReader;
-  pipeThrough(transform: ReadableStreamTransform, options?: PipeToOptions): ReadableStream;
+  pipeThrough(
+    transform: ReadableStreamTransform,
+    options?: PipeToOptions
+  ): ReadableStream;
   pipeTo(destination: WritableStream, options?: PipeToOptions): Promise<void>;
   tee(): [ReadableStream, ReadableStream];
+  values(
+    options?: ReadableStreamValuesOptions
+  ): AsyncIterableIterator<ReadableStreamReadResult>;
+  [Symbol.asyncIterator](
+    options?: ReadableStreamValuesOptions
+  ): AsyncIterableIterator<ReadableStreamReadResult>;
 }
 
 declare class ReadableStreamBYOBReader {
   constructor(stream: ReadableStream);
   readonly closed: Promise<void>;
   cancel(reason?: any): Promise<void>;
-  read<T extends ArrayBufferView>(view: T): Promise<ReadableStreamReadResult<T>>;
+  read<T extends ArrayBufferView>(
+    view: T
+  ): Promise<ReadableStreamReadResult<T>>;
   releaseLock(): void;
-  readAtLeast(minBytes: number, view: Uint8Array): Promise<ReadableStreamReadResult<Uint8Array>>;
+  readAtLeast(
+    minBytes: number,
+    view: Uint8Array
+  ): Promise<ReadableStreamReadResult<Uint8Array>>;
+}
+
+declare abstract class ReadableStreamBYOBRequest {
+  readonly view: Uint8Array | null;
+  respond(bytesWritten: number): void;
+  respondWithNewView(view: ArrayBufferView): void;
+  readonly atLeast: number | null;
+}
+
+declare abstract class ReadableStreamDefaultController {
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk?: any): void;
+  error(reason: any): void;
 }
 
 declare class ReadableStreamDefaultReader {
@@ -760,7 +1009,9 @@ interface ReadableStreamGetReaderOptions {
  */
 declare type ReadableStreamPipeToOptions = PipeToOptions;
 
-declare type ReadableStreamReadResult<T = any> = { done: true; value: undefined; } | { done: false; value: T; };
+declare type ReadableStreamReadResult<T = any> =
+  | { done: true; value: undefined }
+  | { done: false; value: T };
 
 /**
  * Back-compat alias.
@@ -772,13 +1023,18 @@ declare type ReadableStreamReadableStreamBYOBReader = ReadableStreamBYOBReader;
  * Back-compat alias.
  * @deprecated Use ReadableStreamDefaultReader
  */
-declare type ReadableStreamReadableStreamDefaultReader = ReadableStreamDefaultReader;
+declare type ReadableStreamReadableStreamDefaultReader =
+  ReadableStreamDefaultReader;
 
 interface ReadableStreamTransform {
   writable: WritableStream;
   readable: ReadableStream;
 }
 
+interface ReadableStreamValuesOptions {
+  preventCancel?: boolean;
+}
+
 declare class Request extends Body {
   constructor(input: Request | string, init?: RequestInit | Request);
   clone(): Request;
@@ -800,10 +1056,10 @@ interface RequestInit {
   /**
    * cf is a union of these two types because there are multiple
    * scenarios in which it might be one or the other.
-   * 
+   *
    * IncomingRequestCfProperties is required to allow
    *   new Request(someUrl, event.request)
-   * 
+   *
    * RequestInitCfProperties is required to allow
    *   new Request(event.request, {cf: { ... } })
    *   fetch(someUrl, {cf: { ... } })
@@ -817,7 +1073,7 @@ interface RequestInit {
  * that you pass as an argument to the Request constructor, you can
  * set certain properties of a `cf` object to control how Cloudflare
  * features are applied to that new Request.
- * 
+ *
  * Note: Currently, these properties cannot be tested in the
  * playground.
  */
@@ -828,7 +1084,7 @@ interface RequestInitCfProperties {
    * "the same" for caching purposes. If a request has the same cache key
    * as some previous request, then we can serve the same cached response for
    * both. (e.g. 'some-key')
-   * 
+   *
    * Only available for Enterprise customers.
    */
   cacheKey?: string;
@@ -846,11 +1102,12 @@ interface RequestInitCfProperties {
   image?: RequestInitCfPropertiesImage;
   minify?: RequestInitCfPropertiesImageMinify;
   mirage?: boolean;
+  polish?: "lossy" | "lossless" | "off";
   /**
    * Redirects the request to an alternate origin server. You can use this,
    * for example, to implement load balancing across several origins.
    * (e.g.us-east.example.com)
-   * 
+   *
    * Note - For security reasons, the hostname set in resolveOverride must
    * be proxied on the same Cloudflare zone of the incoming request.
    * Otherwise, the setting is ignored. CNAME hosts are allowed, so to
@@ -868,6 +1125,13 @@ interface RequestInitCfPropertiesImage extends BasicImageTransformations {
    * easier to specify higher-DPI sizes in <img srcset>.
    */
   dpr?: number;
+  /**
+   * An object with four properties {left, top, right, bottom} that specify
+   * a number of pixels to cut off on each side. Allows removal of borders
+   * or cutting out a specific fragment of an image. Trimming is performed
+   * before resizing or rotation. Takes dpr into account.
+   */
+  trim?: { left?: number; top?: number; right?: number; bottom?: number };
   /**
    * 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
@@ -884,6 +1148,15 @@ interface RequestInitCfPropertiesImage extends BasicImageTransformations {
    *    (before and after resizing), source image’s MIME type, file size, etc.
    */
   format?: "avif" | "webp" | "json";
+  /**
+   * Whether to preserve animation frames from input files. Default is true.
+   * Setting it to false reduces animations to still images. This setting is
+   * recommended when enlarging images or processing arbitrary user content,
+   * because large GIF animations can weigh tens or even hundreds of megabytes.
+   * It is also useful to set anim:false when using format:"json" to get the
+   * response quicker without the number of frames.
+   */
+  anim?: boolean;
   /**
    * What EXIF data should be preserved in the output image. Note that EXIF
    * rotation and embedded color profiles are always applied ("baked in" into
@@ -898,6 +1171,17 @@ interface RequestInitCfPropertiesImage extends BasicImageTransformations {
    *    output formats always discard metadata.
    */
   metadata?: "keep" | "copyright" | "none";
+  /**
+   * Strength of sharpening filter to apply to the image. Floating-point
+   * number between 0 (no sharpening, default) and 10 (maximum). 1.0 is a
+   * recommended value for downscaled images.
+   */
+  sharpen?: number;
+  /**
+   * Radius of a blur filter (approximate gaussian). Maximum supported radius
+   * is 250.
+   */
+  blur?: number;
   /**
    * Overlays are drawn in the order they appear in the array (last array
    * entry is the topmost layer).
@@ -932,9 +1216,9 @@ interface RequestInitCfPropertiesImageDraw extends BasicImageTransformations {
    * positions left side of the overlay 10 pixels from the left edge of the
    * image it's drawn over. bottom: 0 aligns bottom of the overlay with bottom
    * of the background image.
-   * 
+   *
    * Setting both left & right, or both top & bottom is an error.
-   * 
+   *
    * If no position is specified, the image will be centered.
    */
   top?: number;
@@ -984,6 +1268,12 @@ interface ResponseInit {
  */
 declare type ResponseInitializerDict = ResponseInit;
 
+interface RsaOtherPrimesInfo {
+  r?: string;
+  d?: string;
+  t?: string;
+}
+
 interface ScheduledController {
   readonly scheduledTime: number;
   readonly cron: string;
@@ -997,19 +1287,48 @@ declare abstract class ScheduledEvent extends Event {
   waitUntil(promise: Promise<any>): void;
 }
 
+interface Scheduler {
+  wait(delay: number, maybeOptions?: SchedulerWaitOptions): Promise<void>;
+}
+
+interface SchedulerWaitOptions {
+  signal?: AbortSignal;
+}
+
 interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   btoa(data: string): string;
   atob(data: string): string;
-  setTimeout<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+  setTimeout<Args extends any[]>(
+    callback: (...args: Args) => void,
+    msDelay?: number,
+    ...args: Args
+  ): number;
   clearTimeout(timeoutId: number | null): void;
-  setInterval<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+  setInterval<Args extends any[]>(
+    callback: (...args: Args) => void,
+    msDelay?: number,
+    ...args: Args
+  ): number;
   clearInterval(timeoutId: number | null): void;
   queueMicrotask(task: Function): void;
-  fetch(request: Request | string, requestInitr?: RequestInit | Request): Promise<Response>;
-  readonly self: ServiceWorkerGlobalScope;
-  readonly crypto: Crypto;
-  readonly caches: CacheStorage;
+  structuredClone(
+    value: any,
+    options?: ServiceWorkerGlobalScopeStructuredCloneOptions
+  ): any;
+  fetch(
+    request: Request | string,
+    requestInitr?: RequestInit | Request
+  ): Promise<Response>;
+  self: ServiceWorkerGlobalScope;
+  crypto: Crypto;
+  caches: CacheStorage;
+  scheduler: Scheduler;
   readonly console: Console;
+  origin: void;
+}
+
+interface ServiceWorkerGlobalScopeStructuredCloneOptions {
+  transfer?: any[];
 }
 
 declare type StreamPipeOptions = PipeToOptions;
@@ -1020,18 +1339,71 @@ interface StreamQueuingStrategy {
 }
 
 declare abstract class SubtleCrypto {
-  encrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, plainText: ArrayBuffer): Promise<ArrayBuffer>;
-  decrypt(algorithm: string | SubtleCryptoEncryptAlgorithm, key: CryptoKey, cipherText: ArrayBuffer): Promise<ArrayBuffer>;
-  sign(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, data: ArrayBuffer): Promise<ArrayBuffer>;
-  verify(algorithm: string | SubtleCryptoSignAlgorithm, key: CryptoKey, signature: ArrayBuffer, data: ArrayBuffer): Promise<boolean>;
-  digest(algorithm: string | SubtleCryptoHashAlgorithm, data: ArrayBuffer): Promise<ArrayBuffer>;
-  generateKey(algorithm: string | SubtleCryptoGenerateKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey | CryptoKeyPair>;
-  deriveKey(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, derivedKeyAlgorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
-  deriveBits(algorithm: string | SubtleCryptoDeriveKeyAlgorithm, baseKey: CryptoKey, length: number | null): Promise<ArrayBuffer>;
-  importKey(format: string, keyData: ArrayBuffer | SubtleCryptoJsonWebKey, algorithm: string | SubtleCryptoImportKeyAlgorithm, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
-  exportKey(format: string, key: CryptoKey): Promise<ArrayBuffer | SubtleCryptoJsonWebKey>;
-  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>;
+  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 SubtleCryptoDeriveKeyAlgorithm {
@@ -1074,32 +1446,17 @@ interface SubtleCryptoImportKeyAlgorithm {
   compressed?: boolean;
 }
 
-interface SubtleCryptoJsonWebKey {
-  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?: SubtleCryptoJsonWebKeyRsaOtherPrimesInfo[];
-  k?: string;
-}
+/**
+ *
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ */
+declare type SubtleCryptoJsonWebKey = JsonWebKey;
 
-interface SubtleCryptoJsonWebKeyRsaOtherPrimesInfo {
-  r?: string;
-  d?: string;
-  t?: string;
-}
+/**
+ *
+ * @deprecated Don't use. Introduced incidentally in 3.x. Scheduled for removal.
+ */
+declare type SubtleCryptoJsonWebKeyRsaOtherPrimesInfo = RsaOtherPrimesInfo;
 
 interface SubtleCryptoSignAlgorithm {
   name: string;
@@ -1119,7 +1476,10 @@ interface Text {
 }
 
 declare class TextDecoder {
-  constructor(label?: "utf-8" | "utf8" | "unicode-1-1-utf-8", options?: TextDecoderConstructorOptions);
+  constructor(
+    label?: "utf-8" | "utf8" | "unicode-1-1-utf-8",
+    options?: TextDecoderConstructorOptions
+  );
   decode(input?: ArrayBuffer, options?: TextDecoderDecodeOptions): string;
   readonly encoding: string;
   readonly fatal: boolean;
@@ -1183,12 +1543,24 @@ declare class URLSearchParams {
   entries(): IterableIterator<[key: string, value: string]>;
   keys(): IterableIterator<string>;
   values(): IterableIterator<string>;
-  forEach<This = unknown>(callback: (this: This, key: string, value: string, parent: URLSearchParams) => void, thisArg?: This): void;
+  forEach<This = unknown>(
+    callback: (
+      this: This,
+      key: string,
+      value: string,
+      parent: URLSearchParams
+    ) => void,
+    thisArg?: This
+  ): void;
   [Symbol.iterator](): IterableIterator<[key: string, value: string]>;
   toString(): string;
 }
 
-declare type URLSearchParamsInit = URLSearchParams | string | Record<string, string> | ([key: string, value: string])[];
+declare type URLSearchParamsInit =
+  | URLSearchParams
+  | string
+  | Record<string, string>
+  | [key: string, value: string][];
 
 /**
  * Back compat for code migrating to older definitions.
@@ -1204,26 +1576,40 @@ declare abstract class WebSocket extends EventTarget<WebSocketEventMap> {
   close(code?: number, reason?: string): void;
 }
 
-declare type WebSocketEventMap = { close: CloseEvent; message: MessageEvent; };
-
-declare const WebSocketPair: { new(): { 0: WebSocket; 1: WebSocket; }; };
+declare type WebSocketEventMap = {
+  close: CloseEvent;
+  message: MessageEvent;
+  error: Event;
+};
 
-declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {
+declare const WebSocketPair: { new (): { 0: WebSocket; 1: WebSocket } };
 
-}
+declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEventMap> {}
 
-declare type WorkerGlobalScopeEventMap = { fetch: FetchEvent; scheduled: ScheduledEvent; unhandledrejection: PromiseRejectionEvent; rejectionhandled: PromiseRejectionEvent; };
+declare type WorkerGlobalScopeEventMap = {
+  fetch: FetchEvent;
+  scheduled: ScheduledEvent;
+  unhandledrejection: PromiseRejectionEvent;
+  rejectionhandled: PromiseRejectionEvent;
+};
 
-declare abstract class WritableStream {
+declare class WritableStream {
+  constructor(underlyingSink?: Object, queuingStrategy?: Object);
   readonly locked: boolean;
   abort(reason: any): Promise<void>;
   close(): Promise<void>;
   getWriter(): WritableStreamDefaultWriter;
 }
 
+declare abstract class WritableStreamDefaultController {
+  readonly signal: AbortSignal;
+  error(reason?: any): void;
+}
+
 declare class WritableStreamDefaultWriter {
   constructor(stream: WritableStream);
   readonly closed: Promise<void>;
+  readonly ready: Promise<void>;
   readonly desiredSize: number | null;
   abort(reason: any): Promise<void>;
   close(): Promise<void>;
@@ -1235,9 +1621,14 @@ declare class WritableStreamDefaultWriter {
  * Back-compat alias.
  * @deprecated Use WritableStreamDefaultWriter
  */
-declare type WritableStreamWritableStreamDefaultWriter = WritableStreamDefaultWriter;
+declare type WritableStreamWritableStreamDefaultWriter =
+  WritableStreamDefaultWriter;
 
-declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(type: Type, handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>, options?: EventTargetAddEventListenerOptions | boolean): void;
+declare function addEventListener<Type extends keyof WorkerGlobalScopeEventMap>(
+  type: Type,
+  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
+  options?: EventTargetAddEventListenerOptions | boolean
+): void;
 
 declare function atob(data: string): string;
 
@@ -1253,17 +1644,62 @@ declare const console: Console;
 
 declare const crypto: Crypto;
 
-declare function dispatchEvent(event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]): boolean;
+declare function dispatchEvent(
+  event: WorkerGlobalScopeEventMap[keyof WorkerGlobalScopeEventMap]
+): boolean;
 
-declare function fetch(request: Request | string, requestInitr?: RequestInit | Request): Promise<Response>;
+declare function fetch(
+  request: Request | string,
+  requestInitr?: RequestInit | Request
+): Promise<Response>;
 
-declare function queueMicrotask(task: Function): void;
+declare const origin: void;
 
-declare function removeEventListener<Type extends keyof WorkerGlobalScopeEventMap>(type: Type, handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
+declare function queueMicrotask(task: Function): void;
 
-declare const self: ServiceWorkerGlobalScope;
+declare function removeEventListener<
+  Type extends keyof WorkerGlobalScopeEventMap
+>(
+  type: Type,
+  handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>,
+  options?: EventTargetEventListenerOptions | boolean
+): void;
 
-declare function setInterval<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+declare const scheduler: Scheduler;
 
-declare function setTimeout<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;
+declare const self: ServiceWorkerGlobalScope;
 
+declare function setInterval<Args extends any[]>(
+  callback: (...args: Args) => void,
+  msDelay?: number,
+  ...args: Args
+): number;
+
+declare function setTimeout<Args extends any[]>(
+  callback: (...args: Args) => void,
+  msDelay?: number,
+  ...args: Args
+): number;
+
+declare function structuredClone(
+  value: any,
+  options?: ServiceWorkerGlobalScopeStructuredCloneOptions
+): any;
+
+/*** Injected pages.d.ts ***/
+type Params<P extends string = any> = Record<P, string | string[]>;
+
+type EventContext<Env, P extends string, Data> = {
+  request: Request;
+  waitUntil: (promise: Promise<any>) => void;
+  next: (input?: Request | string, init?: RequestInit) => Promise<Response>;
+  env: Env & { ASSETS: { fetch: typeof fetch } };
+  params: Params<P>;
+  data: Data;
+};
+
+declare type PagesFunction<
+  Env = unknown,
+  Params extends string = any,
+  Data extends Record<string, unknown> = Record<string, unknown>
+> = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>;

package/package.json

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