mirror of
https://github.com/denoland/deno.git
synced 2024-11-01 09:24:20 -04:00
711 lines
22 KiB
TypeScript
711 lines
22 KiB
TypeScript
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
||
|
||
/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, no-var */
|
||
|
||
/// <reference no-default-lib="true" />
|
||
/// <reference lib="esnext" />
|
||
|
||
interface DomIterable<K, V> {
|
||
keys(): IterableIterator<K>;
|
||
values(): IterableIterator<V>;
|
||
entries(): IterableIterator<[K, V]>;
|
||
[Symbol.iterator](): IterableIterator<[K, V]>;
|
||
forEach(
|
||
callback: (value: V, key: K, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
}
|
||
|
||
interface ReadableStreamReadDoneResult<T> {
|
||
done: true;
|
||
value?: T;
|
||
}
|
||
|
||
interface ReadableStreamReadValueResult<T> {
|
||
done: false;
|
||
value: T;
|
||
}
|
||
|
||
type ReadableStreamReadResult<T> =
|
||
| ReadableStreamReadValueResult<T>
|
||
| ReadableStreamReadDoneResult<T>;
|
||
|
||
interface ReadableStreamDefaultReader<R = any> {
|
||
readonly closed: Promise<void>;
|
||
cancel(reason?: any): Promise<void>;
|
||
read(): Promise<ReadableStreamReadResult<R>>;
|
||
releaseLock(): void;
|
||
}
|
||
|
||
interface ReadableStreamReader<R = any> {
|
||
cancel(): Promise<void>;
|
||
read(): Promise<ReadableStreamReadResult<R>>;
|
||
releaseLock(): void;
|
||
}
|
||
|
||
interface ReadableByteStreamControllerCallback {
|
||
(controller: ReadableByteStreamController): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface UnderlyingByteSource {
|
||
autoAllocateChunkSize?: number;
|
||
cancel?: ReadableStreamErrorCallback;
|
||
pull?: ReadableByteStreamControllerCallback;
|
||
start?: ReadableByteStreamControllerCallback;
|
||
type: "bytes";
|
||
}
|
||
|
||
interface UnderlyingSource<R = any> {
|
||
cancel?: ReadableStreamErrorCallback;
|
||
pull?: ReadableStreamDefaultControllerCallback<R>;
|
||
start?: ReadableStreamDefaultControllerCallback<R>;
|
||
type?: undefined;
|
||
}
|
||
|
||
interface ReadableStreamErrorCallback {
|
||
(reason: any): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface ReadableStreamDefaultControllerCallback<R> {
|
||
(controller: ReadableStreamDefaultController<R>): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface ReadableStreamDefaultController<R = any> {
|
||
readonly desiredSize: number | null;
|
||
close(): void;
|
||
enqueue(chunk: R): void;
|
||
error(error?: any): void;
|
||
}
|
||
|
||
interface ReadableByteStreamController {
|
||
readonly byobRequest: undefined;
|
||
readonly desiredSize: number | null;
|
||
close(): void;
|
||
enqueue(chunk: ArrayBufferView): void;
|
||
error(error?: any): void;
|
||
}
|
||
|
||
interface PipeOptions {
|
||
preventAbort?: boolean;
|
||
preventCancel?: boolean;
|
||
preventClose?: boolean;
|
||
signal?: AbortSignal;
|
||
}
|
||
|
||
interface QueuingStrategySizeCallback<T = any> {
|
||
(chunk: T): number;
|
||
}
|
||
|
||
interface QueuingStrategy<T = any> {
|
||
highWaterMark?: number;
|
||
size?: QueuingStrategySizeCallback<T>;
|
||
}
|
||
|
||
/** This Streams API interface provides a built-in byte length queuing strategy
|
||
* that can be used when constructing streams. */
|
||
declare class CountQueuingStrategy implements QueuingStrategy {
|
||
constructor(options: { highWaterMark: number });
|
||
highWaterMark: number;
|
||
size(chunk: any): 1;
|
||
}
|
||
|
||
declare class ByteLengthQueuingStrategy
|
||
implements QueuingStrategy<ArrayBufferView> {
|
||
constructor(options: { highWaterMark: number });
|
||
highWaterMark: number;
|
||
size(chunk: ArrayBufferView): number;
|
||
}
|
||
|
||
/** 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. */
|
||
interface ReadableStream<R = any> {
|
||
readonly locked: boolean;
|
||
cancel(reason?: any): Promise<void>;
|
||
getIterator(options?: { preventCancel?: boolean }): AsyncIterableIterator<R>;
|
||
// getReader(options: { mode: "byob" }): ReadableStreamBYOBReader;
|
||
getReader(): ReadableStreamDefaultReader<R>;
|
||
pipeThrough<T>(
|
||
{
|
||
writable,
|
||
readable,
|
||
}: {
|
||
writable: WritableStream<R>;
|
||
readable: ReadableStream<T>;
|
||
},
|
||
options?: PipeOptions,
|
||
): ReadableStream<T>;
|
||
pipeTo(dest: WritableStream<R>, options?: PipeOptions): Promise<void>;
|
||
tee(): [ReadableStream<R>, ReadableStream<R>];
|
||
[Symbol.asyncIterator](options?: {
|
||
preventCancel?: boolean;
|
||
}): AsyncIterableIterator<R>;
|
||
}
|
||
|
||
declare var ReadableStream: {
|
||
prototype: ReadableStream;
|
||
new (
|
||
underlyingSource: UnderlyingByteSource,
|
||
strategy?: { highWaterMark?: number; size?: undefined },
|
||
): ReadableStream<Uint8Array>;
|
||
new <R = any>(
|
||
underlyingSource?: UnderlyingSource<R>,
|
||
strategy?: QueuingStrategy<R>,
|
||
): ReadableStream<R>;
|
||
};
|
||
|
||
interface WritableStreamDefaultControllerCloseCallback {
|
||
(): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface WritableStreamDefaultControllerStartCallback {
|
||
(controller: WritableStreamDefaultController): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface WritableStreamDefaultControllerWriteCallback<W> {
|
||
(chunk: W, controller: WritableStreamDefaultController):
|
||
| void
|
||
| PromiseLike<
|
||
void
|
||
>;
|
||
}
|
||
|
||
interface WritableStreamErrorCallback {
|
||
(reason: any): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface UnderlyingSink<W = any> {
|
||
abort?: WritableStreamErrorCallback;
|
||
close?: WritableStreamDefaultControllerCloseCallback;
|
||
start?: WritableStreamDefaultControllerStartCallback;
|
||
type?: undefined;
|
||
write?: WritableStreamDefaultControllerWriteCallback<W>;
|
||
}
|
||
|
||
/** This Streams API interface provides a standard abstraction for writing
|
||
* streaming data to a destination, known as a sink. This object comes with
|
||
* built-in backpressure and queuing. */
|
||
declare class WritableStream<W = any> {
|
||
constructor(
|
||
underlyingSink?: UnderlyingSink<W>,
|
||
strategy?: QueuingStrategy<W>,
|
||
);
|
||
readonly locked: boolean;
|
||
abort(reason?: any): Promise<void>;
|
||
close(): Promise<void>;
|
||
getWriter(): WritableStreamDefaultWriter<W>;
|
||
}
|
||
|
||
/** 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. */
|
||
interface WritableStreamDefaultController {
|
||
error(error?: any): void;
|
||
}
|
||
|
||
/** This Streams API interface is the object returned by
|
||
* WritableStream.getWriter() and once created locks the < writer to the
|
||
* WritableStream ensuring that no other streams can write to the underlying
|
||
* sink. */
|
||
interface WritableStreamDefaultWriter<W = any> {
|
||
readonly closed: Promise<void>;
|
||
readonly desiredSize: number | null;
|
||
readonly ready: Promise<void>;
|
||
abort(reason?: any): Promise<void>;
|
||
close(): Promise<void>;
|
||
releaseLock(): void;
|
||
write(chunk: W): Promise<void>;
|
||
}
|
||
|
||
declare class TransformStream<I = any, O = any> {
|
||
constructor(
|
||
transformer?: Transformer<I, O>,
|
||
writableStrategy?: QueuingStrategy<I>,
|
||
readableStrategy?: QueuingStrategy<O>,
|
||
);
|
||
readonly readable: ReadableStream<O>;
|
||
readonly writable: WritableStream<I>;
|
||
}
|
||
|
||
interface TransformStreamDefaultController<O = any> {
|
||
readonly desiredSize: number | null;
|
||
enqueue(chunk: O): void;
|
||
error(reason?: any): void;
|
||
terminate(): void;
|
||
}
|
||
|
||
interface Transformer<I = any, O = any> {
|
||
flush?: TransformStreamDefaultControllerCallback<O>;
|
||
readableType?: undefined;
|
||
start?: TransformStreamDefaultControllerCallback<O>;
|
||
transform?: TransformStreamDefaultControllerTransformCallback<I, O>;
|
||
writableType?: undefined;
|
||
}
|
||
|
||
interface TransformStreamDefaultControllerCallback<O> {
|
||
(controller: TransformStreamDefaultController<O>): void | PromiseLike<void>;
|
||
}
|
||
|
||
interface TransformStreamDefaultControllerTransformCallback<I, O> {
|
||
(
|
||
chunk: I,
|
||
controller: TransformStreamDefaultController<O>,
|
||
): void | PromiseLike<void>;
|
||
}
|
||
|
||
type BlobPart = BufferSource | Blob | string;
|
||
|
||
interface BlobPropertyBag {
|
||
type?: string;
|
||
ending?: "transparent" | "native";
|
||
}
|
||
|
||
/** A file-like object of immutable, raw data. Blobs represent data that isn't necessarily in a JavaScript-native format. The File interface is based on Blob, inheriting blob functionality and expanding it to support files on the user's system. */
|
||
declare class Blob {
|
||
constructor(blobParts?: BlobPart[], options?: BlobPropertyBag);
|
||
|
||
readonly size: number;
|
||
readonly type: string;
|
||
arrayBuffer(): Promise<ArrayBuffer>;
|
||
slice(start?: number, end?: number, contentType?: string): Blob;
|
||
stream(): ReadableStream;
|
||
text(): Promise<string>;
|
||
}
|
||
|
||
interface FilePropertyBag extends BlobPropertyBag {
|
||
lastModified?: number;
|
||
}
|
||
|
||
/** Provides information about files and allows JavaScript in a web page to
|
||
* access their content. */
|
||
declare class File extends Blob {
|
||
constructor(
|
||
fileBits: BlobPart[],
|
||
fileName: string,
|
||
options?: FilePropertyBag,
|
||
);
|
||
|
||
readonly lastModified: number;
|
||
readonly name: string;
|
||
}
|
||
|
||
type FormDataEntryValue = File | string;
|
||
|
||
/** Provides a way to easily construct a set of key/value pairs representing
|
||
* form fields and their values, which can then be easily sent using the
|
||
* XMLHttpRequest.send() method. It uses the same format a form would use if the
|
||
* encoding type were set to "multipart/form-data". */
|
||
declare class FormData implements DomIterable<string, FormDataEntryValue> {
|
||
// TODO(ry) FormData constructor is non-standard.
|
||
// new(form?: HTMLFormElement): FormData;
|
||
constructor();
|
||
|
||
append(name: string, value: string | Blob, fileName?: string): void;
|
||
delete(name: string): void;
|
||
get(name: string): FormDataEntryValue | null;
|
||
getAll(name: string): FormDataEntryValue[];
|
||
has(name: string): boolean;
|
||
set(name: string, value: string | Blob, fileName?: string): void;
|
||
keys(): IterableIterator<string>;
|
||
values(): IterableIterator<string>;
|
||
entries(): IterableIterator<[string, FormDataEntryValue]>;
|
||
[Symbol.iterator](): IterableIterator<[string, FormDataEntryValue]>;
|
||
forEach(
|
||
callback: (value: FormDataEntryValue, key: string, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
}
|
||
|
||
interface Body {
|
||
/** A simple getter used to expose a `ReadableStream` of the body contents. */
|
||
readonly body: ReadableStream<Uint8Array> | null;
|
||
/** Stores a `Boolean` that declares whether the body has been used in a
|
||
* response yet.
|
||
*/
|
||
readonly bodyUsed: boolean;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with an `ArrayBuffer`.
|
||
*/
|
||
arrayBuffer(): Promise<ArrayBuffer>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `Blob`.
|
||
*/
|
||
blob(): Promise<Blob>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `FormData` object.
|
||
*/
|
||
formData(): Promise<FormData>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with the result of parsing the body text as JSON.
|
||
*/
|
||
json(): Promise<any>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `USVString` (text).
|
||
*/
|
||
text(): Promise<string>;
|
||
}
|
||
|
||
type HeadersInit = Headers | string[][] | Record<string, string>;
|
||
|
||
/** This Fetch API interface allows you to perform various actions on HTTP
|
||
* request and response headers. These actions include retrieving, setting,
|
||
* adding to, and removing. A Headers object has an associated header list,
|
||
* which is initially empty and consists of zero or more name and value pairs.
|
||
* You can add to this using methods like append() (see Examples.) In all
|
||
* methods of this interface, header names are matched by case-insensitive byte
|
||
* sequence. */
|
||
interface Headers {
|
||
append(name: string, value: string): void;
|
||
delete(name: string): void;
|
||
get(name: string): string | null;
|
||
has(name: string): boolean;
|
||
set(name: string, value: string): void;
|
||
forEach(
|
||
callbackfn: (value: string, key: string, parent: Headers) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
}
|
||
|
||
declare class Headers implements DomIterable<string, string> {
|
||
constructor(init?: HeadersInit);
|
||
|
||
/** Appends a new value onto an existing header inside a `Headers` object, or
|
||
* adds the header if it does not already exist.
|
||
*/
|
||
append(name: string, value: string): void;
|
||
/** Deletes a header from a `Headers` object. */
|
||
delete(name: string): void;
|
||
/** Returns an iterator allowing to go through all key/value pairs
|
||
* contained in this Headers object. The both the key and value of each pairs
|
||
* are ByteString objects.
|
||
*/
|
||
entries(): IterableIterator<[string, string]>;
|
||
/** Returns a `ByteString` sequence of all the values of a header within a
|
||
* `Headers` object with a given name.
|
||
*/
|
||
get(name: string): string | null;
|
||
/** Returns a boolean stating whether a `Headers` object contains a certain
|
||
* header.
|
||
*/
|
||
has(name: string): boolean;
|
||
/** Returns an iterator allowing to go through all keys contained in
|
||
* this Headers object. The keys are ByteString objects.
|
||
*/
|
||
keys(): IterableIterator<string>;
|
||
/** Sets a new value for an existing header inside a Headers object, or adds
|
||
* the header if it does not already exist.
|
||
*/
|
||
set(name: string, value: string): void;
|
||
/** Returns an iterator allowing to go through all values contained in
|
||
* this Headers object. The values are ByteString objects.
|
||
*/
|
||
values(): IterableIterator<string>;
|
||
forEach(
|
||
callbackfn: (value: string, key: string, parent: this) => void,
|
||
thisArg?: any,
|
||
): void;
|
||
/** The Symbol.iterator well-known symbol specifies the default
|
||
* iterator for this Headers object
|
||
*/
|
||
[Symbol.iterator](): IterableIterator<[string, string]>;
|
||
}
|
||
|
||
type RequestInfo = Request | string;
|
||
type RequestCache =
|
||
| "default"
|
||
| "force-cache"
|
||
| "no-cache"
|
||
| "no-store"
|
||
| "only-if-cached"
|
||
| "reload";
|
||
type RequestCredentials = "include" | "omit" | "same-origin";
|
||
type RequestMode = "cors" | "navigate" | "no-cors" | "same-origin";
|
||
type RequestRedirect = "error" | "follow" | "manual";
|
||
type ReferrerPolicy =
|
||
| ""
|
||
| "no-referrer"
|
||
| "no-referrer-when-downgrade"
|
||
| "origin"
|
||
| "origin-when-cross-origin"
|
||
| "same-origin"
|
||
| "strict-origin"
|
||
| "strict-origin-when-cross-origin"
|
||
| "unsafe-url";
|
||
type BodyInit =
|
||
| Blob
|
||
| BufferSource
|
||
| FormData
|
||
| URLSearchParams
|
||
| ReadableStream<Uint8Array>
|
||
| string;
|
||
type RequestDestination =
|
||
| ""
|
||
| "audio"
|
||
| "audioworklet"
|
||
| "document"
|
||
| "embed"
|
||
| "font"
|
||
| "image"
|
||
| "manifest"
|
||
| "object"
|
||
| "paintworklet"
|
||
| "report"
|
||
| "script"
|
||
| "sharedworker"
|
||
| "style"
|
||
| "track"
|
||
| "video"
|
||
| "worker"
|
||
| "xslt";
|
||
|
||
interface RequestInit {
|
||
/**
|
||
* A BodyInit object or null to set request's body.
|
||
*/
|
||
body?: BodyInit | null;
|
||
/**
|
||
* A string indicating how the request will interact with the browser's cache
|
||
* to set request's cache.
|
||
*/
|
||
cache?: RequestCache;
|
||
/**
|
||
* A string indicating whether credentials will be sent with the request
|
||
* always, never, or only when sent to a same-origin URL. Sets request's
|
||
* credentials.
|
||
*/
|
||
credentials?: RequestCredentials;
|
||
/**
|
||
* A Headers object, an object literal, or an array of two-item arrays to set
|
||
* request's headers.
|
||
*/
|
||
headers?: HeadersInit;
|
||
/**
|
||
* A cryptographic hash of the resource to be fetched by request. Sets
|
||
* request's integrity.
|
||
*/
|
||
integrity?: string;
|
||
/**
|
||
* A boolean to set request's keepalive.
|
||
*/
|
||
keepalive?: boolean;
|
||
/**
|
||
* A string to set request's method.
|
||
*/
|
||
method?: string;
|
||
/**
|
||
* A string to indicate whether the request will use CORS, or will be
|
||
* restricted to same-origin URLs. Sets request's mode.
|
||
*/
|
||
mode?: RequestMode;
|
||
/**
|
||
* A string indicating whether request follows redirects, results in an error
|
||
* upon encountering a redirect, or returns the redirect (in an opaque
|
||
* fashion). Sets request's redirect.
|
||
*/
|
||
redirect?: RequestRedirect;
|
||
/**
|
||
* A string whose value is a same-origin URL, "about:client", or the empty
|
||
* string, to set request's referrer.
|
||
*/
|
||
referrer?: string;
|
||
/**
|
||
* A referrer policy to set request's referrerPolicy.
|
||
*/
|
||
referrerPolicy?: ReferrerPolicy;
|
||
/**
|
||
* An AbortSignal to set request's signal.
|
||
*/
|
||
signal?: AbortSignal | null;
|
||
/**
|
||
* Can only be null. Used to disassociate request from any Window.
|
||
*/
|
||
window?: any;
|
||
}
|
||
|
||
/** This Fetch API interface represents a resource request. */
|
||
declare class Request implements Body {
|
||
constructor(input: RequestInfo, init?: RequestInit);
|
||
|
||
/**
|
||
* Returns the cache mode associated with request, which is a string
|
||
* indicating how the request will interact with the browser's cache when
|
||
* fetching.
|
||
*/
|
||
readonly cache: RequestCache;
|
||
/**
|
||
* Returns the credentials mode associated with request, which is a string
|
||
* indicating whether credentials will be sent with the request always, never,
|
||
* or only when sent to a same-origin URL.
|
||
*/
|
||
readonly credentials: RequestCredentials;
|
||
/**
|
||
* Returns the kind of resource requested by request, e.g., "document" or "script".
|
||
*/
|
||
readonly destination: RequestDestination;
|
||
/**
|
||
* Returns a Headers object consisting of the headers associated with request.
|
||
* Note that headers added in the network layer by the user agent will not be
|
||
* accounted for in this object, e.g., the "Host" header.
|
||
*/
|
||
readonly headers: Headers;
|
||
/**
|
||
* Returns 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]
|
||
*/
|
||
readonly integrity: string;
|
||
/**
|
||
* Returns a boolean indicating whether or not request is for a history
|
||
* navigation (a.k.a. back-forward navigation).
|
||
*/
|
||
readonly isHistoryNavigation: boolean;
|
||
/**
|
||
* Returns a boolean indicating whether or not request is for a reload
|
||
* navigation.
|
||
*/
|
||
readonly isReloadNavigation: boolean;
|
||
/**
|
||
* Returns a boolean indicating whether or not request can outlive the global
|
||
* in which it was created.
|
||
*/
|
||
readonly keepalive: boolean;
|
||
/**
|
||
* Returns request's HTTP method, which is "GET" by default.
|
||
*/
|
||
readonly method: string;
|
||
/**
|
||
* Returns the mode associated with request, which is a string indicating
|
||
* whether the request will use CORS, or will be restricted to same-origin
|
||
* URLs.
|
||
*/
|
||
readonly mode: RequestMode;
|
||
/**
|
||
* Returns the redirect mode associated with request, which is a string
|
||
* indicating how redirects for the request will be handled during fetching. A
|
||
* request will follow redirects by default.
|
||
*/
|
||
readonly redirect: RequestRedirect;
|
||
/**
|
||
* Returns the referrer of request. Its value can be a same-origin URL if
|
||
* explicitly set in init, the empty string to indicate no referrer, and
|
||
* "about:client" when defaulting to the global's default. This is used during
|
||
* fetching to determine the value of the `Referer` header of the request
|
||
* being made.
|
||
*/
|
||
readonly referrer: string;
|
||
/**
|
||
* Returns the referrer policy associated with request. This is used during
|
||
* fetching to compute the value of the request's referrer.
|
||
*/
|
||
readonly referrerPolicy: ReferrerPolicy;
|
||
/**
|
||
* Returns the signal associated with request, which is an AbortSignal object
|
||
* indicating whether or not request has been aborted, and its abort event
|
||
* handler.
|
||
*/
|
||
readonly signal: AbortSignal;
|
||
/**
|
||
* Returns the URL of request as a string.
|
||
*/
|
||
readonly url: string;
|
||
clone(): Request;
|
||
|
||
/** A simple getter used to expose a `ReadableStream` of the body contents. */
|
||
readonly body: ReadableStream<Uint8Array> | null;
|
||
/** Stores a `Boolean` that declares whether the body has been used in a
|
||
* response yet.
|
||
*/
|
||
readonly bodyUsed: boolean;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with an `ArrayBuffer`.
|
||
*/
|
||
arrayBuffer(): Promise<ArrayBuffer>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `Blob`.
|
||
*/
|
||
blob(): Promise<Blob>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `FormData` object.
|
||
*/
|
||
formData(): Promise<FormData>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with the result of parsing the body text as JSON.
|
||
*/
|
||
json(): Promise<any>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `USVString` (text).
|
||
*/
|
||
text(): Promise<string>;
|
||
}
|
||
|
||
interface ResponseInit {
|
||
headers?: HeadersInit;
|
||
status?: number;
|
||
statusText?: string;
|
||
}
|
||
|
||
type ResponseType =
|
||
| "basic"
|
||
| "cors"
|
||
| "default"
|
||
| "error"
|
||
| "opaque"
|
||
| "opaqueredirect";
|
||
|
||
/** This Fetch API interface represents the response to a request. */
|
||
declare class Response implements Body {
|
||
constructor(body?: BodyInit | null, init?: ResponseInit);
|
||
static error(): Response;
|
||
static redirect(url: string, status?: number): Response;
|
||
|
||
readonly headers: Headers;
|
||
readonly ok: boolean;
|
||
readonly redirected: boolean;
|
||
readonly status: number;
|
||
readonly statusText: string;
|
||
readonly trailer: Promise<Headers>;
|
||
readonly type: ResponseType;
|
||
readonly url: string;
|
||
clone(): Response;
|
||
|
||
/** A simple getter used to expose a `ReadableStream` of the body contents. */
|
||
readonly body: ReadableStream<Uint8Array> | null;
|
||
/** Stores a `Boolean` that declares whether the body has been used in a
|
||
* response yet.
|
||
*/
|
||
readonly bodyUsed: boolean;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with an `ArrayBuffer`.
|
||
*/
|
||
arrayBuffer(): Promise<ArrayBuffer>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `Blob`.
|
||
*/
|
||
blob(): Promise<Blob>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `FormData` object.
|
||
*/
|
||
formData(): Promise<FormData>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with the result of parsing the body text as JSON.
|
||
*/
|
||
json(): Promise<any>;
|
||
/** Takes a `Response` stream and reads it to completion. It returns a promise
|
||
* that resolves with a `USVString` (text).
|
||
*/
|
||
text(): Promise<string>;
|
||
}
|
||
|
||
/** Fetch a resource from the network. It returns a Promise that resolves to the
|
||
* Response to that request, whether it is successful or not.
|
||
*
|
||
* const response = await fetch("http://my.json.host/data.json");
|
||
* console.log(response.status); // e.g. 200
|
||
* console.log(response.statusText); // e.g. "OK"
|
||
* const jsonData = await response.json();
|
||
*/
|
||
declare function fetch(
|
||
input: Request | URL | string,
|
||
init?: RequestInit,
|
||
): Promise<Response>;
|