1 |
|
2 |
|
3 |
|
4 |
|
5 |
|
6 |
|
7 |
|
8 |
|
9 |
|
10 | declare function clearInterval(handle: number): void;
|
11 | declare function clearTimeout(handle: number): void;
|
12 | declare function setInterval(handler: (...args: any[]) => void, timeout: number): number;
|
13 | declare function setInterval(handler: any, timeout?: any, ...args: any[]): number;
|
14 | declare function setTimeout(handler: (...args: any[]) => void, timeout: number): number;
|
15 | declare function setTimeout(handler: any, timeout?: any, ...args: any[]): number;
|
16 | declare function clearImmediate(handle: number): void;
|
17 | declare function setImmediate(handler: (...args: any[]) => void): number;
|
18 |
|
19 | declare function cancelAnimationFrame(handle: number): void;
|
20 | declare function requestAnimationFrame(callback: (time: number) => void): number;
|
21 |
|
22 | declare function fetchBundle(bundleId: number, callback: (error?: Error | null) => void): void;
|
23 |
|
24 |
|
25 |
|
26 |
|
27 |
|
28 | declare interface GlobalFetch {
|
29 | fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
30 | }
|
31 |
|
32 | declare function fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
33 |
|
34 | declare interface WindowOrWorkerGlobalScope {
|
35 | fetch(input: RequestInfo, init?: RequestInit): Promise<Response>;
|
36 | }
|
37 |
|
38 | interface Blob {
|
39 | readonly size: number;
|
40 | readonly type: string;
|
41 | slice(start?: number, end?: number): Blob;
|
42 | }
|
43 |
|
44 | interface BlobOptions {
|
45 | type: string;
|
46 | lastModified: number;
|
47 | }
|
48 |
|
49 | declare var Blob: {
|
50 | prototype: Blob;
|
51 | new (blobParts?: Array<Blob | string>, options?: BlobOptions): Blob;
|
52 | };
|
53 |
|
54 | declare class FormData {
|
55 | append(name: string, value: any): void;
|
56 | }
|
57 |
|
58 | declare interface Body {
|
59 | readonly bodyUsed: boolean;
|
60 | arrayBuffer(): Promise<ArrayBuffer>;
|
61 | blob(): Promise<Blob>;
|
62 | json(): Promise<any>;
|
63 | text(): Promise<string>;
|
64 | formData(): Promise<FormData>;
|
65 | }
|
66 |
|
67 | declare interface Headers {
|
68 | append(name: string, value: string): void;
|
69 | delete(name: string): void;
|
70 | forEach(callback: Function, thisArg?: any): void;
|
71 | get(name: string): string | null;
|
72 | has(name: string): boolean;
|
73 | set(name: string, value: string): void;
|
74 | }
|
75 |
|
76 | declare var Headers: {
|
77 | prototype: Headers;
|
78 | new (init?: HeadersInit_): Headers;
|
79 | };
|
80 |
|
81 |
|
82 |
|
83 |
|
84 |
|
85 |
|
86 | interface _SourceUri {
|
87 | uri: string;
|
88 | [key: string]: any;
|
89 | }
|
90 |
|
91 | type BodyInit_ =
|
92 | | _SourceUri
|
93 | | Blob
|
94 | | Int8Array
|
95 | | Int16Array
|
96 | | Int32Array
|
97 | | Uint8Array
|
98 | | Uint16Array
|
99 | | Uint32Array
|
100 | | Uint8ClampedArray
|
101 | | Float32Array
|
102 | | Float64Array
|
103 | | DataView
|
104 | | ArrayBuffer
|
105 | | FormData
|
106 | | string
|
107 | | null;
|
108 |
|
109 | declare interface RequestInit {
|
110 | body?: BodyInit_ | undefined;
|
111 | credentials?: RequestCredentials_ | undefined;
|
112 | headers?: HeadersInit_ | undefined;
|
113 | integrity?: string | undefined;
|
114 | keepalive?: boolean | undefined;
|
115 | method?: string | undefined;
|
116 | mode?: RequestMode_ | undefined;
|
117 | referrer?: string | undefined;
|
118 | window?: any;
|
119 | signal?: AbortSignal | undefined;
|
120 | }
|
121 |
|
122 | declare interface Request extends Object, Body {
|
123 | readonly credentials: RequestCredentials_;
|
124 | readonly headers: Headers;
|
125 | readonly method: string;
|
126 | readonly mode: RequestMode_;
|
127 | readonly referrer: string;
|
128 | readonly url: string;
|
129 | clone(): Request;
|
130 | }
|
131 |
|
132 | declare var Request: {
|
133 | prototype: Request;
|
134 | new (input: Request | string, init?: RequestInit): Request;
|
135 | };
|
136 |
|
137 | declare type RequestInfo = Request | string;
|
138 |
|
139 | declare interface ResponseInit {
|
140 | headers?: HeadersInit_ | undefined;
|
141 | status?: number | undefined;
|
142 | statusText?: string | undefined;
|
143 | }
|
144 |
|
145 | declare interface Response extends Object, Body {
|
146 | readonly headers: Headers;
|
147 | readonly ok: boolean;
|
148 | readonly status: number;
|
149 | readonly statusText: string;
|
150 | readonly type: ResponseType_;
|
151 | readonly url: string;
|
152 | readonly redirected: boolean;
|
153 | clone(): Response;
|
154 | }
|
155 |
|
156 | declare var Response: {
|
157 | prototype: Response;
|
158 | new (body?: BodyInit_, init?: ResponseInit): Response;
|
159 | error: () => Response;
|
160 | redirect: (url: string, status?: number) => Response;
|
161 | };
|
162 |
|
163 | type HeadersInit_ = Headers | string[][] | { [key: string]: string };
|
164 | type RequestCredentials_ = 'omit' | 'same-origin' | 'include';
|
165 | type RequestMode_ = 'navigate' | 'same-origin' | 'no-cors' | 'cors';
|
166 | type ResponseType_ = 'basic' | 'cors' | 'default' | 'error' | 'opaque' | 'opaqueredirect';
|
167 |
|
168 |
|
169 |
|
170 |
|
171 |
|
172 | declare interface ProgressEvent<T extends EventTarget = EventTarget> extends Event {
|
173 | readonly lengthComputable: boolean;
|
174 | readonly loaded: number;
|
175 | readonly total: number;
|
176 | readonly target: T | null;
|
177 | }
|
178 |
|
179 | interface XMLHttpRequestEventMap extends XMLHttpRequestEventTargetEventMap {
|
180 | readystatechange: Event;
|
181 | }
|
182 |
|
183 | interface XMLHttpRequest extends EventTarget, XMLHttpRequestEventTarget {
|
184 |
|
185 | onreadystatechange: ((this: XMLHttpRequest, ev: Event) => any) | null;
|
186 | readonly readyState: number;
|
187 | readonly response: any;
|
188 | readonly responseText: string;
|
189 | responseType: XMLHttpRequestResponseType;
|
190 | readonly responseURL: string;
|
191 | readonly responseXML: Document | null;
|
192 | readonly status: number;
|
193 | readonly statusText: string;
|
194 | timeout: number;
|
195 | readonly upload: XMLHttpRequestUpload;
|
196 | withCredentials: boolean;
|
197 | abort(): void;
|
198 | getAllResponseHeaders(): string;
|
199 | getResponseHeader(header: string): string | null;
|
200 | // msCachingEnabled(): boolean;
|
201 | open(method: string, url: string, async?: boolean, user?: string | null, password?: string | null): void;
|
202 | overrideMimeType(mime: string): void;
|
203 | send(data?: any): void;
|
204 | setRequestHeader(header: string, value: string): void;
|
205 | readonly DONE: number;
|
206 | readonly HEADERS_RECEIVED: number;
|
207 | readonly LOADING: number;
|
208 | readonly OPENED: number;
|
209 | readonly UNSENT: number;
|
210 | addEventListener<K extends keyof XMLHttpRequestEventMap>(
|
211 | type: K,
|
212 | listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any,
|
213 | ): void;
|
214 | // addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
|
215 | removeEventListener<K extends keyof XMLHttpRequestEventMap>(
|
216 | type: K,
|
217 | listener: (this: XMLHttpRequest, ev: XMLHttpRequestEventMap[K]) => any,
|
218 | ): void;
|
219 | // removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
|
220 | }
|
221 |
|
222 | declare var XMLHttpRequest: {
|
223 | prototype: XMLHttpRequest;
|
224 | new (): XMLHttpRequest;
|
225 | readonly DONE: number;
|
226 | readonly HEADERS_RECEIVED: number;
|
227 | readonly LOADING: number;
|
228 | readonly OPENED: number;
|
229 | readonly UNSENT: number;
|
230 | };
|
231 |
|
232 | interface XMLHttpRequestEventTargetEventMap {
|
233 | abort: ProgressEvent;
|
234 | error: ProgressEvent;
|
235 | load: ProgressEvent;
|
236 | loadend: ProgressEvent;
|
237 | loadstart: ProgressEvent;
|
238 | progress: ProgressEvent;
|
239 | timeout: ProgressEvent;
|
240 | }
|
241 |
|
242 | interface XMLHttpRequestEventTarget {
|
243 | onabort: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
244 | onerror: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
245 | onload: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
246 | onloadend: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
247 | onloadstart: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
248 | onprogress: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
249 | ontimeout: ((this: XMLHttpRequest, ev: ProgressEvent) => any) | null;
|
250 | addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(
|
251 | type: K,
|
252 | listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any,
|
253 | ): void;
|
254 | // addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
|
255 | removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(
|
256 | type: K,
|
257 | listener: (this: XMLHttpRequestEventTarget, ev: XMLHttpRequestEventTargetEventMap[K]) => any,
|
258 | ): void;
|
259 | // removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
|
260 | }
|
261 |
|
262 | interface XMLHttpRequestUpload extends EventTarget, XMLHttpRequestEventTarget {
|
263 | addEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(
|
264 | type: K,
|
265 | listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any,
|
266 | ): void;
|
267 | // addEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
|
268 | removeEventListener<K extends keyof XMLHttpRequestEventTargetEventMap>(
|
269 | type: K,
|
270 | listener: (this: XMLHttpRequestUpload, ev: XMLHttpRequestEventTargetEventMap[K]) => any,
|
271 | ): void;
|
272 | // removeEventListener(type: string, listener: EventListenerOrEventListenerObject): void;
|
273 | }
|
274 |
|
275 | declare var XMLHttpRequestUpload: {
|
276 | prototype: XMLHttpRequestUpload;
|
277 | new (): XMLHttpRequestUpload;
|
278 | };
|
279 |
|
280 | declare type XMLHttpRequestResponseType = '' | 'arraybuffer' | 'blob' | 'document' | 'json' | 'text';
|
281 |
|
282 | /**
|
283 | * Based on definition from lib.dom but using class syntax.
|
284 | * The properties are mutable to support users that use a `URL` polyfill, but the implementation
|
285 | * built into React Native (as of 0.63) does not implement all the properties.
|
286 | */
|
287 | declare class URL {
|
288 | static createObjectURL(blob: Blob): string;
|
289 | static revokeObjectURL(url: string): void;
|
290 |
|
291 | constructor(url: string, base?: string);
|
292 |
|
293 | href: string;
|
294 | readonly origin: string;
|
295 | protocol: string;
|
296 | username: string;
|
297 | password: string;
|
298 | host: string;
|
299 | hostname: string;
|
300 | port: string;
|
301 | pathname: string;
|
302 | search: string;
|
303 | readonly searchParams: URLSearchParams;
|
304 | hash: string;
|
305 |
|
306 | toJSON(): string;
|
307 | }
|
308 |
|
309 | /**
|
310 | * Based on definitions of lib.dom and lib.dom.iterable
|
311 | */
|
312 | declare class URLSearchParams {
|
313 | constructor(init?: string[][] | Record<string, string> | string | URLSearchParams);
|
314 |
|
315 | append(name: string, value: string): void;
|
316 | delete(name: string): void;
|
317 | get(name: string): string | null;
|
318 | getAll(name: string): string[];
|
319 | has(name: string): boolean;
|
320 | set(name: string, value: string): void;
|
321 | sort(): void;
|
322 | forEach(callbackfn: (value: string, key: string, parent: URLSearchParams) => void, thisArg?: any): void;
|
323 | [Symbol.iterator](): IterableIterator<[string, string]>;
|
324 |
|
325 | entries(): IterableIterator<[string, string]>;
|
326 | keys(): IterableIterator<string>;
|
327 | values(): IterableIterator<string>;
|
328 | }
|
329 |
|
330 | interface WebSocketMessageEvent extends Event {
|
331 | data?: any;
|
332 | }
|
333 | interface WebSocketErrorEvent extends Event {
|
334 | message: string;
|
335 | }
|
336 | interface WebSocketCloseEvent extends Event {
|
337 | code?: number | undefined;
|
338 | reason?: string | undefined;
|
339 | message?: string | undefined;
|
340 | }
|
341 |
|
342 | type WebsocketMessageEventListener = (event: 'message', handler: (e: WebSocketMessageEvent) => void) => void;
|
343 | type WebsocketErrorEventListener = (event: 'error', handler: (e: WebSocketErrorEvent) => void) => void;
|
344 | type WebsocketOpenEventListener = (event: 'open', handler: () => void) => void;
|
345 | type WebsocketCloseEventListener = (event: 'close', handler: (e: WebSocketCloseEvent) => void) => void;
|
346 |
|
347 | type WebsocketEventListener = WebsocketMessageEventListener &
|
348 | WebsocketErrorEventListener &
|
349 | WebsocketOpenEventListener &
|
350 | WebsocketCloseEventListener;
|
351 |
|
352 | interface WebSocket extends EventTarget {
|
353 | readonly readyState: number;
|
354 | send(data: string | ArrayBuffer | ArrayBufferView | Blob): void;
|
355 | close(code?: number, reason?: string): void;
|
356 | onopen: (() => void) | null;
|
357 | onmessage: ((event: WebSocketMessageEvent) => void) | null;
|
358 | onerror: ((event: WebSocketErrorEvent) => void) | null;
|
359 | onclose: ((event: WebSocketCloseEvent) => void) | null;
|
360 | addEventListener: WebsocketEventListener;
|
361 | removeEventListener: WebsocketEventListener;
|
362 | }
|
363 |
|
364 | declare var WebSocket: {
|
365 | prototype: WebSocket;
|
366 | new (
|
367 | uri: string,
|
368 | protocols?: string | string[] | null,
|
369 | options?: {
|
370 | headers: { [headerName: string]: string };
|
371 | [optionName: string]: any;
|
372 | } | null,
|
373 | ): WebSocket;
|
374 | readonly CLOSED: number;
|
375 | readonly CLOSING: number;
|
376 | readonly CONNECTING: number;
|
377 | readonly OPEN: number;
|
378 | };
|
379 |
|
380 | //
|
381 | // Abort Controller
|
382 | //
|
383 |
|
384 | interface AbortEvent extends Event {
|
385 | type: 'abort';
|
386 | }
|
387 |
|
388 | declare class AbortSignal implements EventTarget {
|
389 | /**
|
390 | * AbortSignal cannot be constructed directly.
|
391 | */
|
392 | constructor();
|
393 | /**
|
394 | * Returns `true` if this `AbortSignal`'s `AbortController` has signaled to abort, and `false` otherwise.
|
395 | */
|
396 | readonly aborted: boolean;
|
397 |
|
398 | onabort: (event: AbortEvent) => void;
|
399 |
|
400 | addEventListener: (type: "abort", listener: ((this: AbortSignal, event: any) => any), options?: boolean | {
|
401 | capture?: boolean,
|
402 | once?: boolean,
|
403 | passive?: boolean
|
404 | }) => void;
|
405 |
|
406 | removeEventListener: (type: "abort", listener: ((this: AbortSignal, event: any) => any), options?: boolean | {
|
407 | capture?: boolean
|
408 | }) => void;
|
409 | }
|
410 |
|
411 | declare class AbortController {
|
412 | |
413 |
|
414 |
|
415 | constructor();
|
416 | /**
|
417 | * Returns the `AbortSignal` object associated with this object.
|
418 | */
|
419 | readonly signal: AbortSignal;
|
420 | /**
|
421 | * Abort and signal to any observers that the associated activity is to be aborted.
|
422 | */
|
423 | abort(): void;
|
424 | }
|
425 |
|
426 | interface FileReaderEventMap {
|
427 | abort: ProgressEvent<FileReader>;
|
428 | error: ProgressEvent<FileReader>;
|
429 | load: ProgressEvent<FileReader>;
|
430 | loadend: ProgressEvent<FileReader>;
|
431 | loadstart: ProgressEvent<FileReader>;
|
432 | progress: ProgressEvent<FileReader>;
|
433 | }
|
434 |
|
435 | interface FileReader extends EventTarget {
|
436 | readonly error: Error | null;
|
437 | onabort: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
438 | onerror: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
439 | onload: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
440 | onloadend: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
441 | onloadstart: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
442 | onprogress: ((this: FileReader, ev: ProgressEvent<FileReader>) => any) | null;
|
443 | readonly readyState: number;
|
444 | readonly result: string | ArrayBuffer;
|
445 | abort(): void;
|
446 | readAsArrayBuffer(blob: Blob): void;
|
447 | // readAsBinaryString(blob: Blob): void;
|
448 | readAsDataURL(blob: Blob): void;
|
449 | readAsText(blob: Blob, encoding?: string): void;
|
450 | readonly DONE: number;
|
451 | readonly EMPTY: number;
|
452 | readonly LOADING: number;
|
453 | addEventListener<K extends keyof FileReaderEventMap>(
|
454 | type: K,
|
455 | listener: (this: FileReader, ev: FileReaderEventMap[K]) => any,
|
456 | options?: boolean,
|
457 | ): void;
|
458 | // addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
|
459 | removeEventListener<K extends keyof FileReaderEventMap>(
|
460 | type: K,
|
461 | listener: (this: FileReader, ev: FileReaderEventMap[K]) => any,
|
462 | options?: boolean,
|
463 | ): void;
|
464 | // removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
|
465 | }
|
466 |
|
467 | declare var FileReader: {
|
468 | prototype: FileReader;
|
469 | new (): FileReader;
|
470 | readonly DONE: number;
|
471 | readonly EMPTY: number;
|
472 | readonly LOADING: number;
|
473 | };
|
474 |
|
\ | No newline at end of file |