Updated types for 2021.12.300

index.d.ts

@@ -10,8 +10,10 @@ declare class AbortController {
 declare class AbortSignal extends EventTarget {
   constructor();
   static abort(reason?: any): AbortSignal;
+  static timeout(delay: number): AbortSignal;
   readonly aborted: boolean;
   readonly reason: any;
+  throwIfAborted(): void;
 }
 
 interface BasicImageTransformations {
@@ -268,6 +270,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;
@@ -764,7 +771,16 @@ interface ReadResult {
   done: boolean;
 }
 
-declare abstract class ReadableStream {
+interface 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;
@@ -783,6 +799,20 @@ declare class ReadableStreamBYOBReader {
   readAtLeast(minBytes: number, view: Uint8Array): Promise<ReadableStreamReadResult<Uint8Array>>;
 }
 
+interface ReadableStreamBYOBRequest {
+  readonly view: Uint8Array | null;
+  respond(bytesWritten: number): void;
+  respondWithNewView(view: ArrayBufferView): void;
+  readonly atLeast: number | null;
+}
+
+interface ReadableStreamDefaultController {
+  readonly desiredSize: number | null;
+  close(): void;
+  enqueue(chunk?: any): void;
+  error(reason: any): void;
+}
+
 declare class ReadableStreamDefaultReader {
   constructor(stream: ReadableStream);
   readonly closed: Promise<void>;
@@ -1072,6 +1102,14 @@ 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;
@@ -1085,6 +1123,7 @@ interface ServiceWorkerGlobalScope extends WorkerGlobalScope {
   readonly self: ServiceWorkerGlobalScope;
   readonly crypto: Crypto;
   readonly caches: CacheStorage;
+  readonly scheduler: Scheduler;
   readonly console: Console;
 }
 
@@ -1279,13 +1318,19 @@ declare abstract class WorkerGlobalScope extends EventTarget<WorkerGlobalScopeEv
 
 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;
 }
 
+interface WritableStreamDefaultController {
+  readonly signal: AbortSignal;
+  error(reason?: any): void;
+}
+
 declare class WritableStreamDefaultWriter {
   constructor(stream: WritableStream);
   readonly closed: Promise<void>;
@@ -1327,6 +1372,8 @@ declare function queueMicrotask(task: Function): void;
 
 declare function removeEventListener<Type extends keyof WorkerGlobalScopeEventMap>(type: Type, handler: EventListenerOrEventListenerObject<WorkerGlobalScopeEventMap[Type]>, options?: EventTargetEventListenerOptions | boolean): void;
 
+declare const scheduler: Scheduler;
+
 declare const self: ServiceWorkerGlobalScope;
 
 declare function setInterval<Args extends any[]>(callback: (...args: Args) => void, msDelay?: number, ...args: Args): number;