-
Notifications
You must be signed in to change notification settings - Fork 21
/
index.d.ts
181 lines (129 loc) · 4.68 KB
/
index.d.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
import { Readable, Stream } from 'stream'
import { AuthInfo, Session } from 'electron'
import { Agent } from 'https'
export default fetch
declare function fetch (
url: RequestInfo,
options?: RequestInit
): Promise<Response>
export enum FetchErrorType {
BodyTimeout = "body-timeout",
System = "system",
MaxSize = "max-size",
Abort = "abort",
RequestTimeout = "request-timeout",
Proxy = "proxy",
NoRedirect = "no-redirect",
MaxRedirect = "max-redirect",
InvalidRedirect = "invalid-redirect",
}
export class FetchError extends Error {
constructor(message: string, type: FetchErrorType, systemError?: { code: string });
type: string;
code?: string;
}
export type HeadersInit = Headers | string[][] | { [key: string]: string }
export class Headers {
constructor (init?: HeadersInit)
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
// WebIDL pair iterator: iterable<ByteString, ByteString>
entries (): IterableIterator<[string, string]>
forEach (callback: (value: string, name: string, headers: Headers) => void, thisArg?: any): void
keys (): IterableIterator<string>
values (): IterableIterator<string>
[Symbol.iterator] (): IterableIterator<[string, string]>
}
export type BodyInit = Stream | string | Blob | Buffer | null
export interface Body {
readonly bodyUsed: boolean
arrayBuffer (): Promise<ArrayBuffer>
blob (): Promise<Blob>
formData (): Promise<FormData>
json<T = any> (): Promise<T>
text (): Promise<string>
buffer (): Promise<Buffer>
}
export class Response implements Body {
constructor (body: BodyInit, init?: ResponseInit)
readonly url: string
readonly status: number
readonly ok: boolean
readonly statusText: string
readonly headers: Headers
readonly body: Readable | string
clone (): Response
// Body impl
readonly bodyUsed: boolean
arrayBuffer (): Promise<ArrayBuffer>
blob (): Promise<Blob>
formData (): Promise<FormData>
json<T = any> (): Promise<T>
text (): Promise<string>
buffer (): Promise<Buffer>
}
export interface RequestInit {
// These properties are part of the Fetch Standard
method?: string
headers?: HeadersInit
body?: BodyInit
signal?: AbortSignal
// (/!\ only works when running on Node.js) set to `manual` to extract redirect headers, `error` to reject redirect
redirect?: RequestRedirect
////////////////////////////////////////////////////////////////////////////
// The following properties are electron-fetch extensions
// (/!\ only works when running on Node.js) maximum redirect count. 0 to not follow redirect
follow?: number
// req/res timeout in ms, it resets on redirect. 0 to disable (OS limit applies)
timeout?: number
// maximum response body size in bytes. 0 to disable
size?: number
session?: Session
agent?: Agent,
useElectronNet?: boolean
useSessionCookies?: boolean
// When running on Electron behind an authenticated HTTP proxy, username to use to authenticate
user?: string
// When running on Electron behind an authenticated HTTP proxy, password to use to authenticate
password?: string
/**
* When running on Electron behind an authenticated HTTP proxy, handler of `electron.ClientRequest`'s `login` event.
* Can be used for acquiring proxy credentials in an async manner (e.g. prompting the user).
*/
onLogin?: (authInfo: AuthInfo) => Promise<{ username: string, password: string } | undefined>
}
export type RequestInfo = Request | string
export class Request implements Body {
constructor (input: RequestInfo, init?: RequestInit)
readonly method: string
readonly url: string
readonly headers: Headers
readonly redirect: RequestRedirect
readonly signal: AbortSignal
clone (): Request
////////////////////////////////////////////////////////////////////////////
// The following properties are electron-fetch extensions
// (/!\ only works when running on Node.js) maximum redirect count. 0 to not follow redirect
follow: number
// (/!\ only works when running on Node.js)
counter: number
// (/!\ only works when running on Electron)
session?: Session
// (/!\ only works when running on Electron, throws when set to true on Node.js)
useElectronNet: boolean
// (/!\ only works when running on Electron)
useSessionCookies?: boolean
////////////////////////////////////////////////////////////////////////////
// Body impl
readonly bodyUsed: boolean
arrayBuffer (): Promise<ArrayBuffer>
blob (): Promise<Blob>
formData (): Promise<FormData>
json<T = any> (): Promise<T>
text (): Promise<string>
buffer (): Promise<Buffer>
readonly body: Readable
}