@veilway/sdk 0.0.0-stage → 0.1.0-alpha
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +47 -2
- package/dist/src/index.d.ts +93 -0
- package/dist/src/index.js +136 -0
- package/dist/src/schema.d.ts +2069 -0
- package/dist/src/schema.js +5 -0
- package/package.json +37 -5
|
@@ -0,0 +1,2069 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* This file was auto-generated by openapi-typescript.
|
|
3
|
+
* Do not make direct changes to the file.
|
|
4
|
+
*/
|
|
5
|
+
export interface paths {
|
|
6
|
+
"/v1/config": {
|
|
7
|
+
parameters: {
|
|
8
|
+
query?: never;
|
|
9
|
+
header?: never;
|
|
10
|
+
path?: never;
|
|
11
|
+
cookie?: never;
|
|
12
|
+
};
|
|
13
|
+
/** The running config with every secret replaced by the marker "<redacted>", and its revision, which is also the ETag. */
|
|
14
|
+
get: operations["getConfig"];
|
|
15
|
+
/** Puts a config in force, the way a reload on SIGHUP does, and writes it to the config file. If-Match must name the revision the change was made on. A document that is refused changes nothing. An outbound keeps its username and password for a marker only while its server is the same. */
|
|
16
|
+
put: operations["applyConfig"];
|
|
17
|
+
post?: never;
|
|
18
|
+
delete?: never;
|
|
19
|
+
options?: never;
|
|
20
|
+
head?: never;
|
|
21
|
+
patch?: never;
|
|
22
|
+
trace?: never;
|
|
23
|
+
};
|
|
24
|
+
"/v1/config/diff": {
|
|
25
|
+
parameters: {
|
|
26
|
+
query?: never;
|
|
27
|
+
header?: never;
|
|
28
|
+
path?: never;
|
|
29
|
+
cookie?: never;
|
|
30
|
+
};
|
|
31
|
+
get?: never;
|
|
32
|
+
put?: never;
|
|
33
|
+
/** What an apply of the document would add, change and remove, by tag and name. Nothing changes. An outbound whose username or password is written out, and not left as the marker, is listed as changed whatever they are. */
|
|
34
|
+
post: operations["diffConfig"];
|
|
35
|
+
delete?: never;
|
|
36
|
+
options?: never;
|
|
37
|
+
head?: never;
|
|
38
|
+
patch?: never;
|
|
39
|
+
trace?: never;
|
|
40
|
+
};
|
|
41
|
+
"/v1/config/validate": {
|
|
42
|
+
parameters: {
|
|
43
|
+
query?: never;
|
|
44
|
+
header?: never;
|
|
45
|
+
path?: never;
|
|
46
|
+
cookie?: never;
|
|
47
|
+
};
|
|
48
|
+
get?: never;
|
|
49
|
+
put?: never;
|
|
50
|
+
/** Validates a document and changes nothing. Errors and warnings name the path of a field and never its value. */
|
|
51
|
+
post: operations["validateConfig"];
|
|
52
|
+
delete?: never;
|
|
53
|
+
options?: never;
|
|
54
|
+
head?: never;
|
|
55
|
+
patch?: never;
|
|
56
|
+
trace?: never;
|
|
57
|
+
};
|
|
58
|
+
"/v1/events": {
|
|
59
|
+
parameters: {
|
|
60
|
+
query?: never;
|
|
61
|
+
header?: never;
|
|
62
|
+
path?: never;
|
|
63
|
+
cookie?: never;
|
|
64
|
+
};
|
|
65
|
+
/** Server-Sent Events: config_applied, config_refused, user_cut_off, user_restored, usage_reset, exit_udp_changed, and stats once a second. Each has an increasing id. A reader that is too slow loses events and gets a lagged event, which has no id, saying how many. A comment line every 15 seconds keeps the stream alive. */
|
|
66
|
+
get: operations["events"];
|
|
67
|
+
put?: never;
|
|
68
|
+
post?: never;
|
|
69
|
+
delete?: never;
|
|
70
|
+
options?: never;
|
|
71
|
+
head?: never;
|
|
72
|
+
patch?: never;
|
|
73
|
+
trace?: never;
|
|
74
|
+
};
|
|
75
|
+
"/v1/exits": {
|
|
76
|
+
parameters: {
|
|
77
|
+
query?: never;
|
|
78
|
+
header?: never;
|
|
79
|
+
path?: never;
|
|
80
|
+
cookie?: never;
|
|
81
|
+
};
|
|
82
|
+
/** Every exit with what the node knows of its upstream, and its counters. */
|
|
83
|
+
get: operations["listExits"];
|
|
84
|
+
put?: never;
|
|
85
|
+
post?: never;
|
|
86
|
+
delete?: never;
|
|
87
|
+
options?: never;
|
|
88
|
+
head?: never;
|
|
89
|
+
patch?: never;
|
|
90
|
+
trace?: never;
|
|
91
|
+
};
|
|
92
|
+
"/v1/inbounds": {
|
|
93
|
+
parameters: {
|
|
94
|
+
query?: never;
|
|
95
|
+
header?: never;
|
|
96
|
+
path?: never;
|
|
97
|
+
cookie?: never;
|
|
98
|
+
};
|
|
99
|
+
/** Every inbound of the running config with its WireGuard public key, the public half of its node transport key, and the rating of each transport: what a censor can see of a profile of it. No private key. */
|
|
100
|
+
get: operations["listInbounds"];
|
|
101
|
+
put?: never;
|
|
102
|
+
post?: never;
|
|
103
|
+
delete?: never;
|
|
104
|
+
options?: never;
|
|
105
|
+
head?: never;
|
|
106
|
+
patch?: never;
|
|
107
|
+
trace?: never;
|
|
108
|
+
};
|
|
109
|
+
"/v1/links": {
|
|
110
|
+
parameters: {
|
|
111
|
+
query?: never;
|
|
112
|
+
header?: never;
|
|
113
|
+
path?: never;
|
|
114
|
+
cookie?: never;
|
|
115
|
+
};
|
|
116
|
+
/** Every enabled node link with its state and its counters. No key and no secret. */
|
|
117
|
+
get: operations["listLinks"];
|
|
118
|
+
put?: never;
|
|
119
|
+
post?: never;
|
|
120
|
+
delete?: never;
|
|
121
|
+
options?: never;
|
|
122
|
+
head?: never;
|
|
123
|
+
patch?: never;
|
|
124
|
+
trace?: never;
|
|
125
|
+
};
|
|
126
|
+
"/v1/openapi.json": {
|
|
127
|
+
parameters: {
|
|
128
|
+
query?: never;
|
|
129
|
+
header?: never;
|
|
130
|
+
path?: never;
|
|
131
|
+
cookie?: never;
|
|
132
|
+
};
|
|
133
|
+
/** This document. */
|
|
134
|
+
get: operations["openapi"];
|
|
135
|
+
put?: never;
|
|
136
|
+
post?: never;
|
|
137
|
+
delete?: never;
|
|
138
|
+
options?: never;
|
|
139
|
+
head?: never;
|
|
140
|
+
patch?: never;
|
|
141
|
+
trace?: never;
|
|
142
|
+
};
|
|
143
|
+
"/v1/replay/reset": {
|
|
144
|
+
parameters: {
|
|
145
|
+
query?: never;
|
|
146
|
+
header?: never;
|
|
147
|
+
path?: never;
|
|
148
|
+
cookie?: never;
|
|
149
|
+
};
|
|
150
|
+
get?: never;
|
|
151
|
+
put?: never;
|
|
152
|
+
/** Resets the replay memory of the obfuscated transports: the cache of accepted proofs is emptied, and the floor and the limit become the node's clock plus 60 seconds, written to the replay file before the next proof is accepted. It ends the state in which the floor is ahead of the clock. It costs two things: every client is refused for 60 seconds, and a proof that was accepted with a timestamp above the new floor is forgotten, so whoever recorded it can use it once more when the clock reaches that timestamp. Nothing else of the node is touched, usage and quotas included. The answer is the replay memory after the reset. */
|
|
153
|
+
post: operations["resetReplay"];
|
|
154
|
+
delete?: never;
|
|
155
|
+
options?: never;
|
|
156
|
+
head?: never;
|
|
157
|
+
patch?: never;
|
|
158
|
+
trace?: never;
|
|
159
|
+
};
|
|
160
|
+
"/v1/sessions": {
|
|
161
|
+
parameters: {
|
|
162
|
+
query?: never;
|
|
163
|
+
header?: never;
|
|
164
|
+
path?: never;
|
|
165
|
+
cookie?: never;
|
|
166
|
+
};
|
|
167
|
+
/** The devices with a live session. */
|
|
168
|
+
get: operations["listSessions"];
|
|
169
|
+
put?: never;
|
|
170
|
+
post?: never;
|
|
171
|
+
delete?: never;
|
|
172
|
+
options?: never;
|
|
173
|
+
head?: never;
|
|
174
|
+
patch?: never;
|
|
175
|
+
trace?: never;
|
|
176
|
+
};
|
|
177
|
+
"/v1/stats": {
|
|
178
|
+
parameters: {
|
|
179
|
+
query?: never;
|
|
180
|
+
header?: never;
|
|
181
|
+
path?: never;
|
|
182
|
+
cookie?: never;
|
|
183
|
+
};
|
|
184
|
+
/** Every counter at one moment, with rates in bytes per second over the last 5 seconds. */
|
|
185
|
+
get: operations["stats"];
|
|
186
|
+
put?: never;
|
|
187
|
+
post?: never;
|
|
188
|
+
delete?: never;
|
|
189
|
+
options?: never;
|
|
190
|
+
head?: never;
|
|
191
|
+
patch?: never;
|
|
192
|
+
trace?: never;
|
|
193
|
+
};
|
|
194
|
+
"/v1/status": {
|
|
195
|
+
parameters: {
|
|
196
|
+
query?: never;
|
|
197
|
+
header?: never;
|
|
198
|
+
path?: never;
|
|
199
|
+
cookie?: never;
|
|
200
|
+
};
|
|
201
|
+
/** What runs: the version, the config in force and how much of everything there is. */
|
|
202
|
+
get: operations["status"];
|
|
203
|
+
put?: never;
|
|
204
|
+
post?: never;
|
|
205
|
+
delete?: never;
|
|
206
|
+
options?: never;
|
|
207
|
+
head?: never;
|
|
208
|
+
patch?: never;
|
|
209
|
+
trace?: never;
|
|
210
|
+
};
|
|
211
|
+
"/v1/users": {
|
|
212
|
+
parameters: {
|
|
213
|
+
query?: never;
|
|
214
|
+
header?: never;
|
|
215
|
+
path?: never;
|
|
216
|
+
cookie?: never;
|
|
217
|
+
};
|
|
218
|
+
/** Every user of the running config with their usage, counters and devices. */
|
|
219
|
+
get: operations["listUsers"];
|
|
220
|
+
put?: never;
|
|
221
|
+
post?: never;
|
|
222
|
+
delete?: never;
|
|
223
|
+
options?: never;
|
|
224
|
+
head?: never;
|
|
225
|
+
patch?: never;
|
|
226
|
+
trace?: never;
|
|
227
|
+
};
|
|
228
|
+
"/v1/users/{name}": {
|
|
229
|
+
parameters: {
|
|
230
|
+
query?: never;
|
|
231
|
+
header?: never;
|
|
232
|
+
path?: never;
|
|
233
|
+
cookie?: never;
|
|
234
|
+
};
|
|
235
|
+
/** One user. */
|
|
236
|
+
get: operations["getUser"];
|
|
237
|
+
put?: never;
|
|
238
|
+
post?: never;
|
|
239
|
+
delete?: never;
|
|
240
|
+
options?: never;
|
|
241
|
+
head?: never;
|
|
242
|
+
patch?: never;
|
|
243
|
+
trace?: never;
|
|
244
|
+
};
|
|
245
|
+
"/v1/users/{name}/usage/reset": {
|
|
246
|
+
parameters: {
|
|
247
|
+
query?: never;
|
|
248
|
+
header?: never;
|
|
249
|
+
path?: never;
|
|
250
|
+
cookie?: never;
|
|
251
|
+
};
|
|
252
|
+
get?: never;
|
|
253
|
+
put?: never;
|
|
254
|
+
/** Starts a user's quota count over: used_bytes is 0 and period_start is the start of the quota period the node's clock is in, or 0 for a user without a quota_period. A user who was out of quota may connect again at once, with no reload. traffic stays as it is unless the body says {"totals": true}, and the body may be left out. The state file is written before the answer. The same request again changes nothing more. The answer is the user as GET /v1/users/{name} gives them. */
|
|
255
|
+
post: operations["resetUsage"];
|
|
256
|
+
delete?: never;
|
|
257
|
+
options?: never;
|
|
258
|
+
head?: never;
|
|
259
|
+
patch?: never;
|
|
260
|
+
trace?: never;
|
|
261
|
+
};
|
|
262
|
+
}
|
|
263
|
+
export type webhooks = Record<string, never>;
|
|
264
|
+
export interface components {
|
|
265
|
+
schemas: {
|
|
266
|
+
Addons: {
|
|
267
|
+
xray: components["schemas"]["XrayAddon"];
|
|
268
|
+
};
|
|
269
|
+
Applied: {
|
|
270
|
+
diff: components["schemas"]["Diff"];
|
|
271
|
+
/** Format: uint64 */
|
|
272
|
+
generation: number;
|
|
273
|
+
/** @description The warnings of the config that is now in force. */
|
|
274
|
+
report: components["schemas"]["Report"];
|
|
275
|
+
revision: string;
|
|
276
|
+
/** @description Why the write failed, as the system names it. */
|
|
277
|
+
save_error: string | null;
|
|
278
|
+
/**
|
|
279
|
+
* @description False when the config is in force and could not be written to the config file: a restart would come back with the config before. Sending the same document again tries the write again.
|
|
280
|
+
* A write that was given up on after 10 seconds is not stopped, so the file may still come to hold this config. It never goes back to an older one.
|
|
281
|
+
*/
|
|
282
|
+
saved: boolean;
|
|
283
|
+
};
|
|
284
|
+
/** @enum {string} */
|
|
285
|
+
Backend: "netstack" | "l3" | "block" | "chain";
|
|
286
|
+
/** @description Tags or names of one kind. */
|
|
287
|
+
Changes: {
|
|
288
|
+
added: string[];
|
|
289
|
+
changed: string[];
|
|
290
|
+
removed: string[];
|
|
291
|
+
};
|
|
292
|
+
/** @description The data of a `config_applied` event. */
|
|
293
|
+
ConfigApplied: {
|
|
294
|
+
diff: components["schemas"]["Diff"];
|
|
295
|
+
/** Format: uint64 */
|
|
296
|
+
generation: number;
|
|
297
|
+
revision: string;
|
|
298
|
+
};
|
|
299
|
+
/** @description The data of a `config_refused` event: a reload or an apply that left the running config in force. */
|
|
300
|
+
ConfigRefused: {
|
|
301
|
+
/** Format: uint */
|
|
302
|
+
errors: number;
|
|
303
|
+
stage: components["schemas"]["Stage"];
|
|
304
|
+
};
|
|
305
|
+
/** @description What the control channel of the `veilway` inbounds did since start. Everything but `open` only grows. */
|
|
306
|
+
Control: {
|
|
307
|
+
/**
|
|
308
|
+
* Format: uint64
|
|
309
|
+
* @description TCP connections to the control port that the node took, and those that proved a transport secret of their device.
|
|
310
|
+
*/
|
|
311
|
+
accepted: number;
|
|
312
|
+
/**
|
|
313
|
+
* Format: uint64
|
|
314
|
+
* @description Connections closed for a wrong credential.
|
|
315
|
+
*/
|
|
316
|
+
auth_failed: number;
|
|
317
|
+
/** Format: uint64 */
|
|
318
|
+
authenticated: number;
|
|
319
|
+
/**
|
|
320
|
+
* Format: uint64
|
|
321
|
+
* @description `bye` messages written before a cut-off or a stop.
|
|
322
|
+
*/
|
|
323
|
+
byes: number;
|
|
324
|
+
/** Format: uint64 */
|
|
325
|
+
exits_dropped: number;
|
|
326
|
+
/** Format: uint64 */
|
|
327
|
+
exits_refused: number;
|
|
328
|
+
/**
|
|
329
|
+
* Format: uint64
|
|
330
|
+
* @description Exit selections that were taken, that were refused, and that a reload dropped.
|
|
331
|
+
*/
|
|
332
|
+
exits_selected: number;
|
|
333
|
+
/**
|
|
334
|
+
* Format: uint64
|
|
335
|
+
* @description Connections closed for a message that was malformed, not allowed where it came, or outside its bounds.
|
|
336
|
+
*/
|
|
337
|
+
malformed: number;
|
|
338
|
+
/**
|
|
339
|
+
* Format: uint64
|
|
340
|
+
* @description MTUs that devices set.
|
|
341
|
+
*/
|
|
342
|
+
mtus_set: number;
|
|
343
|
+
/**
|
|
344
|
+
* Format: uint64
|
|
345
|
+
* @description Authenticated connections open right now.
|
|
346
|
+
*/
|
|
347
|
+
open: number;
|
|
348
|
+
/**
|
|
349
|
+
* Format: uint64
|
|
350
|
+
* @description MTU probe runs that were started, probes from devices that were confirmed, probes the node sent, and datagrams to the probe port that were no probe of a live run.
|
|
351
|
+
*/
|
|
352
|
+
probe_runs: number;
|
|
353
|
+
/** Format: uint64 */
|
|
354
|
+
probes_confirmed: number;
|
|
355
|
+
/** Format: uint64 */
|
|
356
|
+
probes_refused: number;
|
|
357
|
+
/** Format: uint64 */
|
|
358
|
+
probes_sent: number;
|
|
359
|
+
/**
|
|
360
|
+
* Format: uint64
|
|
361
|
+
* @description Requests answered "rate limited".
|
|
362
|
+
*/
|
|
363
|
+
rate_limited: number;
|
|
364
|
+
/**
|
|
365
|
+
* Format: uint64
|
|
366
|
+
* @description Connections closed to make room for a newer one of the same device.
|
|
367
|
+
*/
|
|
368
|
+
replaced: number;
|
|
369
|
+
/**
|
|
370
|
+
* Format: uint64
|
|
371
|
+
* @description Connections closed because the opening exchange was not done within 10 seconds.
|
|
372
|
+
*/
|
|
373
|
+
timed_out: number;
|
|
374
|
+
};
|
|
375
|
+
/** @enum {string} */
|
|
376
|
+
Denied: "disabled" | "expired" | "quota";
|
|
377
|
+
Device: {
|
|
378
|
+
addresses: string[];
|
|
379
|
+
/**
|
|
380
|
+
* Format: uint64
|
|
381
|
+
* @description Seconds since the session the device has was made. Null without a session.
|
|
382
|
+
*/
|
|
383
|
+
handshake_age_secs: number | null;
|
|
384
|
+
name: string;
|
|
385
|
+
public_key: string;
|
|
386
|
+
};
|
|
387
|
+
/** @description What an apply adds, changes and removes, by tag and name. */
|
|
388
|
+
Diff: {
|
|
389
|
+
dns: boolean;
|
|
390
|
+
exits: components["schemas"]["Changes"];
|
|
391
|
+
inbound_changes: components["schemas"]["InboundChange"][];
|
|
392
|
+
inbounds: components["schemas"]["Changes"];
|
|
393
|
+
log: boolean;
|
|
394
|
+
notices: boolean;
|
|
395
|
+
outbounds: components["schemas"]["Changes"];
|
|
396
|
+
public_addresses: boolean;
|
|
397
|
+
/** @description `replay` changed. The rate per source is in force at once, the cache size from the next start of the node. */
|
|
398
|
+
replay: boolean;
|
|
399
|
+
routing_default: boolean;
|
|
400
|
+
rules: components["schemas"]["Changes"];
|
|
401
|
+
rules_reordered: boolean;
|
|
402
|
+
user_changes: components["schemas"]["UserChange"][];
|
|
403
|
+
users: components["schemas"]["Changes"];
|
|
404
|
+
};
|
|
405
|
+
Difference: {
|
|
406
|
+
/** @description Against the running config. Null for a document that is not valid. */
|
|
407
|
+
diff: components["schemas"]["Diff"] | null;
|
|
408
|
+
report: components["schemas"]["Report"];
|
|
409
|
+
valid: boolean;
|
|
410
|
+
};
|
|
411
|
+
/** @description What the node's resolver did with the DNS queries of its tunnels since start. */
|
|
412
|
+
Dns: {
|
|
413
|
+
/** Format: uint64 */
|
|
414
|
+
answered: number;
|
|
415
|
+
/** Format: uint64 */
|
|
416
|
+
failed: number;
|
|
417
|
+
/** Format: uint64 */
|
|
418
|
+
malformed: number;
|
|
419
|
+
/** Format: uint64 */
|
|
420
|
+
refused: number;
|
|
421
|
+
/** Format: uint64 */
|
|
422
|
+
throttled: number;
|
|
423
|
+
};
|
|
424
|
+
/** @description A config version 1 document, see schema/config.v1.json. In an answer every secret (private_key, preshared_key, username, password) holds the marker "<redacted>", and every entry of transport_secrets holds a marker that names it, "<redacted:" with eight hex digits and ">". In a request a marker stands for the value the same object has in the running config: the inbound with that tag, the device with that public_key, the socks5 outbound with that tag and that server. A marker in transport_secrets stands for the secret of that device which it names, wherever it is in the list: an entry that is left out is removed, and a marker that names no secret of the device is an error. An outbound whose server is new or has changed needs its username and password written out. */
|
|
425
|
+
Document: Record<string, never>;
|
|
426
|
+
/** @description The one shape of every answer that is not a success. */
|
|
427
|
+
ErrorBody: {
|
|
428
|
+
error: components["schemas"]["Failure"];
|
|
429
|
+
};
|
|
430
|
+
Exit: {
|
|
431
|
+
backend: components["schemas"]["Backend"];
|
|
432
|
+
/**
|
|
433
|
+
* Format: uint64
|
|
434
|
+
* @description Seconds since the interface went down. Null while `interface_up` is not false.
|
|
435
|
+
*/
|
|
436
|
+
interface_down_secs: number | null;
|
|
437
|
+
/**
|
|
438
|
+
* Format: uint64
|
|
439
|
+
* @description How often the interface switched between up and down.
|
|
440
|
+
*/
|
|
441
|
+
interface_flips: number;
|
|
442
|
+
/** @description Whether the interface of an l3 backend is up. While it is not, what is routed to the exit is answered as unreachable and the node tries to bring the interface up again: 2 seconds after it went down, then after twice the wait each time, once a minute at most. Null for any other backend. */
|
|
443
|
+
interface_up: boolean | null;
|
|
444
|
+
/**
|
|
445
|
+
* Format: uint64
|
|
446
|
+
* @description How long the proxy of the outbound took to answer the greeting of the last flow that dialled it, in milliseconds. Null for a direct outbound, for an exit with no SOCKS5 outbound, and until a flow has used the proxy. A reload starts it over.
|
|
447
|
+
*/
|
|
448
|
+
latency_ms: number | null;
|
|
449
|
+
/** @description Whether one of those links is up. While none is, what is routed to the exit is answered as unreachable and leaves no other way. Null for every other backend. */
|
|
450
|
+
link_up: boolean | null;
|
|
451
|
+
/** @description The node links of a chain backend, by tag, which `/v1/links` reports on. Empty for every other backend. */
|
|
452
|
+
links: string[];
|
|
453
|
+
/**
|
|
454
|
+
* Format: int64
|
|
455
|
+
* @description Unix seconds when `latency_ms` was measured.
|
|
456
|
+
*/
|
|
457
|
+
measured_at: number | null;
|
|
458
|
+
name: string;
|
|
459
|
+
/** @description The tag of the outbound of a netstack backend. */
|
|
460
|
+
outbound: string | null;
|
|
461
|
+
tag: string;
|
|
462
|
+
traffic: components["schemas"]["Traffic"];
|
|
463
|
+
/** @description Whether the SOCKS5 proxy of the exit relays UDP as far as the node knows. Null for an exit without one. */
|
|
464
|
+
udp: boolean | null;
|
|
465
|
+
/**
|
|
466
|
+
* Format: uint64
|
|
467
|
+
* @description Seconds since the proxy last refused to relay UDP. The node tries again once a minute. Null while `udp` is not false.
|
|
468
|
+
*/
|
|
469
|
+
udp_down_secs: number | null;
|
|
470
|
+
/**
|
|
471
|
+
* Format: uint64
|
|
472
|
+
* @description How often the proxy switched between relaying UDP and not.
|
|
473
|
+
*/
|
|
474
|
+
udp_flips: number;
|
|
475
|
+
};
|
|
476
|
+
/** @description The data of an `exit_udp_changed` event. */
|
|
477
|
+
ExitUdpChanged: {
|
|
478
|
+
exit: string;
|
|
479
|
+
udp: boolean;
|
|
480
|
+
};
|
|
481
|
+
Exits: {
|
|
482
|
+
exits: components["schemas"]["Exit"][];
|
|
483
|
+
};
|
|
484
|
+
Failure: {
|
|
485
|
+
/** @description Stable, for programs. */
|
|
486
|
+
code: string;
|
|
487
|
+
/** @description For a config that was refused, every error with the path of its field. For a stale revision, one entry with the path `revision` and the revision that runs. */
|
|
488
|
+
details: components["schemas"]["Problem"][];
|
|
489
|
+
/** @description One plain sentence, for people. */
|
|
490
|
+
message: string;
|
|
491
|
+
};
|
|
492
|
+
/** @description an IP address or a lowercase host name, with no port */
|
|
493
|
+
Host: string;
|
|
494
|
+
InboundChange: {
|
|
495
|
+
/** @description The tunnel restarts and every session of it drops. */
|
|
496
|
+
restart: boolean;
|
|
497
|
+
tag: string;
|
|
498
|
+
/** @description Indexes into the transports of the new inbound. */
|
|
499
|
+
transports_started: number[];
|
|
500
|
+
/** @description Indexes into the transports of the running inbound. */
|
|
501
|
+
transports_stopped: number[];
|
|
502
|
+
};
|
|
503
|
+
/** @description An inbound with what a client profile takes from it. No private key. */
|
|
504
|
+
InboundInfo: {
|
|
505
|
+
kind: components["schemas"]["InboundKind"];
|
|
506
|
+
/** @description The WireGuard public key of the inbound. */
|
|
507
|
+
public_key: components["schemas"]["Key"];
|
|
508
|
+
tag: string;
|
|
509
|
+
/** @description The public half of the node transport key a profile carries. Null for an inbound with no `transport_keys`. */
|
|
510
|
+
transport_public_key: components["schemas"]["Key"] | null;
|
|
511
|
+
transports: components["schemas"]["InboundTransport"][];
|
|
512
|
+
};
|
|
513
|
+
/** @enum {string} */
|
|
514
|
+
InboundKind: "wireguard" | "veilway";
|
|
515
|
+
/** @description One transport of an inbound, with the rating a profile of it gets. */
|
|
516
|
+
InboundTransport: {
|
|
517
|
+
rating: components["schemas"]["Rating"];
|
|
518
|
+
transport: components["schemas"]["Transport"];
|
|
519
|
+
};
|
|
520
|
+
Inbounds: {
|
|
521
|
+
inbounds: components["schemas"]["InboundInfo"][];
|
|
522
|
+
/** @description The node's public addresses, as `GET /v1/status` gives them. */
|
|
523
|
+
public_addresses: components["schemas"]["Host"][];
|
|
524
|
+
};
|
|
525
|
+
/** @description a WireGuard key: 44 characters of standard base64 with padding */
|
|
526
|
+
Key: string;
|
|
527
|
+
/** @description The data of a `lagged` event: this many events, the ones whose ids are missing before the next event, never reached the reader. It was too slow for them, or the node made them faster than it keeps them for anybody. It has no id. */
|
|
528
|
+
Lagged: {
|
|
529
|
+
/** Format: uint64 */
|
|
530
|
+
missed: number;
|
|
531
|
+
};
|
|
532
|
+
/** @description One node link. It holds no key and no secret. */
|
|
533
|
+
Link: {
|
|
534
|
+
/** Format: uint */
|
|
535
|
+
candidate_index: number | null;
|
|
536
|
+
/** @description On the exit half: why this node cut the link off. Null for a link that may run. */
|
|
537
|
+
denied: components["schemas"]["Denied"] | null;
|
|
538
|
+
/**
|
|
539
|
+
* Format: uint64
|
|
540
|
+
* @description Packets that came out of the link and were not carried: on the entry half what answers no flow, on the exit half what the gate, the source check or a limit refused.
|
|
541
|
+
*/
|
|
542
|
+
dropped: number;
|
|
543
|
+
/** @description On the entry half: the exit with a chain backend the link is behind. */
|
|
544
|
+
exit: string | null;
|
|
545
|
+
/**
|
|
546
|
+
* Format: uint
|
|
547
|
+
* @description The flows the link carries: the translations of the entry half, or the flows of the exit half in the flow table.
|
|
548
|
+
*/
|
|
549
|
+
flows: number;
|
|
550
|
+
half: components["schemas"]["LinkHalf"];
|
|
551
|
+
/**
|
|
552
|
+
* Format: uint64
|
|
553
|
+
* @description Seconds since the link's tunnel last completed a handshake. Null without a session.
|
|
554
|
+
*/
|
|
555
|
+
handshake_secs: number | null;
|
|
556
|
+
id: components["schemas"]["LinkId"];
|
|
557
|
+
role: components["schemas"]["LinkRole"];
|
|
558
|
+
/** @description The system refused an outer packet of the link for its size within the last 600 seconds, which suggests the link's mtu is too high for the path. Anyone on the path can forge such a report, so it only warns. */
|
|
559
|
+
size_warning: boolean;
|
|
560
|
+
state: components["schemas"]["LinkState"];
|
|
561
|
+
/**
|
|
562
|
+
* Format: uint64
|
|
563
|
+
* @description How often `state` changed.
|
|
564
|
+
*/
|
|
565
|
+
state_flips: number;
|
|
566
|
+
/**
|
|
567
|
+
* Format: uint64
|
|
568
|
+
* @description Seconds the link has been in `state`.
|
|
569
|
+
*/
|
|
570
|
+
state_secs: number;
|
|
571
|
+
tag: string;
|
|
572
|
+
/** @description Inner packets. Up is what this node sent into the link, down what it took out of it. */
|
|
573
|
+
traffic: components["schemas"]["Traffic"];
|
|
574
|
+
/** @description On the node that dials: the transport it is at, and the places of that transport and of its candidate or endpoint in the other node's list, from 0. Null on the node that is dialled. */
|
|
575
|
+
transport: components["schemas"]["Transport"] | null;
|
|
576
|
+
/** Format: uint */
|
|
577
|
+
transport_index: number | null;
|
|
578
|
+
};
|
|
579
|
+
LinkHalf: "entry" | "exit";
|
|
580
|
+
/** @description the id of a link: 22 characters of base64url without padding */
|
|
581
|
+
LinkId: string;
|
|
582
|
+
LinkRole: "listener" | "dialler";
|
|
583
|
+
LinkState: "up" | "connecting" | "unreachable" | "refused" | "ended";
|
|
584
|
+
Links: {
|
|
585
|
+
links: components["schemas"]["Link"][];
|
|
586
|
+
};
|
|
587
|
+
/**
|
|
588
|
+
* @description The counters of one outbound: those of the exits that leave through it, added up, with what the node knows of its proxy.
|
|
589
|
+
* The node learns whether a proxy relays UDP once for each exit, from the flows of that exit, so two exits through one proxy can know different things for a while. This is what they know together.
|
|
590
|
+
*/
|
|
591
|
+
OutboundStats: {
|
|
592
|
+
/** Format: uint64 */
|
|
593
|
+
down_bytes_per_sec: number;
|
|
594
|
+
/**
|
|
595
|
+
* Format: uint64
|
|
596
|
+
* @description How long the proxy took to answer the greeting of the last flow that dialled it, in milliseconds. Null for a direct outbound, and until a flow has used the proxy. A reload starts it over.
|
|
597
|
+
*/
|
|
598
|
+
latency_ms: number | null;
|
|
599
|
+
/**
|
|
600
|
+
* Format: int64
|
|
601
|
+
* @description Unix seconds when `latency_ms` was measured.
|
|
602
|
+
*/
|
|
603
|
+
measured_at: number | null;
|
|
604
|
+
/** @description The tag of the outbound. */
|
|
605
|
+
name: string;
|
|
606
|
+
/** @description The sum of `traffic` over the exits whose backend names this outbound, all zero for an outbound no exit uses. It holds everything those exits count, which includes what their `unsupported` policy sent around the proxy with `"direct"`. */
|
|
607
|
+
traffic: components["schemas"]["Traffic"];
|
|
608
|
+
/** @description Whether the SOCKS5 proxy relays UDP as far as the node knows: false while any exit through it was last refused. Null for an outbound that is no SOCKS5 proxy. */
|
|
609
|
+
udp: boolean | null;
|
|
610
|
+
/**
|
|
611
|
+
* Format: uint64
|
|
612
|
+
* @description Seconds since the proxy last refused to relay UDP for any of its exits. Null while `udp` is not false.
|
|
613
|
+
*/
|
|
614
|
+
udp_down_secs: number | null;
|
|
615
|
+
/**
|
|
616
|
+
* Format: uint64
|
|
617
|
+
* @description How often the proxy switched between relaying UDP and not, added up over its exits. Exits that learn of one change each count it.
|
|
618
|
+
*/
|
|
619
|
+
udp_flips: number;
|
|
620
|
+
/**
|
|
621
|
+
* Format: uint64
|
|
622
|
+
* @description The sums of the rates of those exits.
|
|
623
|
+
*/
|
|
624
|
+
up_bytes_per_sec: number;
|
|
625
|
+
};
|
|
626
|
+
/** @description One problem of a config document: where it is and what was expected there. It never holds a value from the document. */
|
|
627
|
+
Problem: {
|
|
628
|
+
message: string;
|
|
629
|
+
path: string;
|
|
630
|
+
};
|
|
631
|
+
/** @enum {string} */
|
|
632
|
+
QuotaPeriod: "daily" | "weekly" | "monthly";
|
|
633
|
+
/** @description The counters of one user, inbound or exit, with how fast they grew over the last seconds. */
|
|
634
|
+
Rated: {
|
|
635
|
+
/** Format: uint64 */
|
|
636
|
+
down_bytes_per_sec: number;
|
|
637
|
+
/** @description The user's name, or the tag of the inbound or exit. */
|
|
638
|
+
name: string;
|
|
639
|
+
traffic: components["schemas"]["Traffic"];
|
|
640
|
+
/** Format: uint64 */
|
|
641
|
+
up_bytes_per_sec: number;
|
|
642
|
+
};
|
|
643
|
+
/**
|
|
644
|
+
* @description What a censor can see of a profile's connection, computed here so that the panel and the clients agree. See PLAN.md, "three ratings".
|
|
645
|
+
* @enum {string}
|
|
646
|
+
*/
|
|
647
|
+
Rating: "protected" | "detectable" | "unsafe";
|
|
648
|
+
/** @enum {string} */
|
|
649
|
+
Reason: "disabled" | "expired" | "quota" | "removed";
|
|
650
|
+
/** @description The replay memory of the node. Times are Unix seconds on the node's clock. */
|
|
651
|
+
Replay: {
|
|
652
|
+
/** Format: uint */
|
|
653
|
+
capacity: number;
|
|
654
|
+
/** Format: uint64 */
|
|
655
|
+
clock: number;
|
|
656
|
+
/**
|
|
657
|
+
* Format: uint64
|
|
658
|
+
* @description The highest limit that may be on disk, which a start after a kill takes as its floor.
|
|
659
|
+
*/
|
|
660
|
+
disk_limit: number;
|
|
661
|
+
/** Format: uint */
|
|
662
|
+
entries: number;
|
|
663
|
+
/**
|
|
664
|
+
* Format: uint64
|
|
665
|
+
* @description A proof with a timestamp at or below the floor is refused.
|
|
666
|
+
*/
|
|
667
|
+
floor: number;
|
|
668
|
+
/** @description The floor is ahead of the clock in a way no start explains: more than 80 seconds, or risen while the node ran. Every proof of a client with a right clock is refused until the clock passes the floor or the replay memory is reset. After a start or a reset the floor is up to 80 seconds ahead, which is what they cost and is false here. */
|
|
669
|
+
floor_ahead: boolean;
|
|
670
|
+
/**
|
|
671
|
+
* Format: uint64
|
|
672
|
+
* @description A proof with a timestamp above the limit is not accepted before a higher limit is written.
|
|
673
|
+
*/
|
|
674
|
+
limit: number;
|
|
675
|
+
/**
|
|
676
|
+
* Format: uint64
|
|
677
|
+
* @description How often the node brought its own limit down after a clock that had run ahead.
|
|
678
|
+
*/
|
|
679
|
+
limit_lowered: number;
|
|
680
|
+
/** @description False while no proof is accepted at all: a reset whose file is not known to be on disk. */
|
|
681
|
+
ready: boolean;
|
|
682
|
+
/**
|
|
683
|
+
* Format: uint64
|
|
684
|
+
* @description Proofs refused at the floor while `floor_ahead` was true.
|
|
685
|
+
*/
|
|
686
|
+
refused_floor_ahead: number;
|
|
687
|
+
/**
|
|
688
|
+
* Format: uint64
|
|
689
|
+
* @description How many seconds the floor is ahead of the clock, whatever the cause: for that long proofs with a right clock are refused. 0 on a node that takes them.
|
|
690
|
+
*/
|
|
691
|
+
refusing_secs: number;
|
|
692
|
+
/** Format: uint64 */
|
|
693
|
+
resets: number;
|
|
694
|
+
/** Format: uint64 */
|
|
695
|
+
slow_writes: number;
|
|
696
|
+
/** Format: uint64 */
|
|
697
|
+
write_failures: number;
|
|
698
|
+
/**
|
|
699
|
+
* Format: uint64
|
|
700
|
+
* @description Writes of the replay file that went through, that failed, and that took more than 2 seconds.
|
|
701
|
+
*/
|
|
702
|
+
writes: number;
|
|
703
|
+
};
|
|
704
|
+
Report: {
|
|
705
|
+
errors: components["schemas"]["Problem"][];
|
|
706
|
+
/**
|
|
707
|
+
* Format: uint
|
|
708
|
+
* @description Errors beyond the first hundred, which are only counted.
|
|
709
|
+
*/
|
|
710
|
+
more_errors: number;
|
|
711
|
+
/** Format: uint */
|
|
712
|
+
more_warnings: number;
|
|
713
|
+
/** @description The check for rules covered by an earlier rule stopped at its budget. */
|
|
714
|
+
shadow_cut_short: boolean;
|
|
715
|
+
warnings: components["schemas"]["Problem"][];
|
|
716
|
+
};
|
|
717
|
+
/** @description What a usage reset zeroes besides the quota count. The body may be left out altogether. */
|
|
718
|
+
ResetUsage: {
|
|
719
|
+
/**
|
|
720
|
+
* @description Whether traffic, what the user sent and received in all, goes back to zero as well. Left out or false, only used_bytes and period_start start over.
|
|
721
|
+
* @default false
|
|
722
|
+
*/
|
|
723
|
+
totals: boolean;
|
|
724
|
+
};
|
|
725
|
+
Running: {
|
|
726
|
+
document: components["schemas"]["Document"];
|
|
727
|
+
/** Format: uint64 */
|
|
728
|
+
generation: number;
|
|
729
|
+
revision: string;
|
|
730
|
+
};
|
|
731
|
+
/** @description A certificate the node made for a `tls` listener, with the key it keeps. */
|
|
732
|
+
SelfSigned: {
|
|
733
|
+
/** @description The listen address, as the config writes it. */
|
|
734
|
+
listen: string;
|
|
735
|
+
/**
|
|
736
|
+
* Format: int64
|
|
737
|
+
* @description Unix seconds, 80 to 100 days after `not_before`, drawn per certificate. Clients do not check it.
|
|
738
|
+
*/
|
|
739
|
+
not_after: number;
|
|
740
|
+
/**
|
|
741
|
+
* Format: int64
|
|
742
|
+
* @description Unix seconds. The node makes the certificate anew with the same key 20 days before `not_after`.
|
|
743
|
+
*/
|
|
744
|
+
not_before: number;
|
|
745
|
+
/** @description The SHA-256 of the key's SubjectPublicKeyInfo, in standard base64: the pin a profile's candidate carries with `self_signed`. It stays the same when the certificate is made anew. */
|
|
746
|
+
pin: string;
|
|
747
|
+
};
|
|
748
|
+
/** @description A device with a live session on one inbound. The address the device connects from is not part of it. */
|
|
749
|
+
Session: {
|
|
750
|
+
/**
|
|
751
|
+
* Format: uint
|
|
752
|
+
* @description The authenticated control connections the device has open.
|
|
753
|
+
*/
|
|
754
|
+
control_connections: number;
|
|
755
|
+
device: string;
|
|
756
|
+
/**
|
|
757
|
+
* Format: uint
|
|
758
|
+
* @description The flows of the device, through all its inbounds together.
|
|
759
|
+
*/
|
|
760
|
+
flows: number;
|
|
761
|
+
/** Format: uint64 */
|
|
762
|
+
handshake_age_secs: number;
|
|
763
|
+
inbound: string;
|
|
764
|
+
/**
|
|
765
|
+
* Format: uint16
|
|
766
|
+
* @description The MTU the device set on the control channel. Null for a device that set none, whose tunnel has the `mtu` of its inbound.
|
|
767
|
+
*/
|
|
768
|
+
mtu: number | null;
|
|
769
|
+
public_key: string;
|
|
770
|
+
/** @description The exit the device chose on the control channel for the action `"user"`. Null for a device that chose none and leaves through its user's exit. */
|
|
771
|
+
selected_exit: string | null;
|
|
772
|
+
/** @description Null when the transport the device came over is gone. */
|
|
773
|
+
transport: components["schemas"]["Transport"] | null;
|
|
774
|
+
user: string;
|
|
775
|
+
};
|
|
776
|
+
Sessions: {
|
|
777
|
+
sessions: components["schemas"]["Session"][];
|
|
778
|
+
};
|
|
779
|
+
/** @enum {string} */
|
|
780
|
+
Stage: "validate" | "prepare";
|
|
781
|
+
Stats: {
|
|
782
|
+
control: components["schemas"]["Control"];
|
|
783
|
+
dns: components["schemas"]["Dns"];
|
|
784
|
+
/** @description Packets that were not carried since start, by reason. */
|
|
785
|
+
drops: {
|
|
786
|
+
[key: string]: number;
|
|
787
|
+
};
|
|
788
|
+
exits: components["schemas"]["Rated"][];
|
|
789
|
+
/** Format: uint */
|
|
790
|
+
flows: number;
|
|
791
|
+
inbounds: components["schemas"]["Rated"][];
|
|
792
|
+
/** @description Every outbound of the running config, in its order. An exit with an `l3` or `block` backend has no outbound and is in none of them. */
|
|
793
|
+
outbounds: components["schemas"]["OutboundStats"][];
|
|
794
|
+
/** @description The replay memory of the obfuscated transports. Null for a node that never ran one, which keeps no replay memory. */
|
|
795
|
+
replay: components["schemas"]["Replay"] | null;
|
|
796
|
+
/**
|
|
797
|
+
* Format: uint64
|
|
798
|
+
* @description Datagrams the node made for a device and no socket took, over every transport of every inbound. A socket of a `veilway` inbound never fragments, so a packet larger than the host's interface carries is counted here and not sent: lower the inbound's `mtu` when this grows.
|
|
799
|
+
*/
|
|
800
|
+
send_failed: number;
|
|
801
|
+
/**
|
|
802
|
+
* Format: uint64
|
|
803
|
+
* @description Writes of the usage state file that failed since start.
|
|
804
|
+
*/
|
|
805
|
+
state_write_failures: number;
|
|
806
|
+
stream: components["schemas"]["Stream"];
|
|
807
|
+
udp_obfs: components["schemas"]["UdpObfs"];
|
|
808
|
+
users: components["schemas"]["Rated"][];
|
|
809
|
+
/**
|
|
810
|
+
* Format: uint64
|
|
811
|
+
* @description The seconds the rates were taken over: 5 once the node has run that long, 0 before its second sample.
|
|
812
|
+
*/
|
|
813
|
+
window_secs: number;
|
|
814
|
+
/** Format: uint64 */
|
|
815
|
+
ws_refused: number;
|
|
816
|
+
/**
|
|
817
|
+
* Format: uint64
|
|
818
|
+
* @description WebSocket connections dropped because they never finished the upgrade, and refused at accept.
|
|
819
|
+
*/
|
|
820
|
+
ws_stalled: number;
|
|
821
|
+
};
|
|
822
|
+
Status: {
|
|
823
|
+
addons: components["schemas"]["Addons"];
|
|
824
|
+
/** @description The self-signed certificates the node made for its `tls` transports with `"self_signed": true`, one for each listen address. Empty for a node that has none. */
|
|
825
|
+
certificates: components["schemas"]["SelfSigned"][];
|
|
826
|
+
/** Format: uint */
|
|
827
|
+
exits: number;
|
|
828
|
+
/**
|
|
829
|
+
* Format: uint
|
|
830
|
+
* @description Flows in the flow table right now.
|
|
831
|
+
*/
|
|
832
|
+
flows: number;
|
|
833
|
+
/**
|
|
834
|
+
* Format: uint64
|
|
835
|
+
* @description Starts at 1 and grows by one with every config that is put in force.
|
|
836
|
+
*/
|
|
837
|
+
generation: number;
|
|
838
|
+
/** Format: uint */
|
|
839
|
+
inbounds: number;
|
|
840
|
+
/** @description The node's public addresses, as the config names them: host names or IP addresses, with no port. A profile is given these, each with the port of one of its transports. Empty for a node that names none. */
|
|
841
|
+
public_addresses: components["schemas"]["Host"][];
|
|
842
|
+
/** @description What `If-Match` takes: 64 hex digits that name the bytes of the running config. Only this run of the node gives them this name: nobody else can work it out from a document, and after a restart the same config has another one. */
|
|
843
|
+
revision: string;
|
|
844
|
+
/** Format: uint64 */
|
|
845
|
+
uptime_secs: number;
|
|
846
|
+
/** Format: uint */
|
|
847
|
+
users: number;
|
|
848
|
+
version: string;
|
|
849
|
+
};
|
|
850
|
+
/** @description What the stream listeners of the `tls` transports, and of the `ws` and `fronted` transports of `veilway` inbounds, did since start, and what they hold right now. Everything but `undecided`, `relayed`, `pending`, `sessions`, `proxies`, `decoys` and `fronted` only grows. Whoever is not a user gets the decoy origin's answer whatever the reason, and no reason holds an address, a path, a token or a key. */
|
|
851
|
+
Stream: {
|
|
852
|
+
/** Format: uint64 */
|
|
853
|
+
accept_failed: number;
|
|
854
|
+
/**
|
|
855
|
+
* Format: uint64
|
|
856
|
+
* @description Connections the listeners took from the system, and failures to take one, which is what a host that is out of file descriptors shows.
|
|
857
|
+
*/
|
|
858
|
+
accepted: number;
|
|
859
|
+
/**
|
|
860
|
+
* Format: uint64
|
|
861
|
+
* @description Connections that broke before they were decided, with an error that is no close: a reset inside the request line, or a connection whose own address could not be read.
|
|
862
|
+
*/
|
|
863
|
+
broken: number;
|
|
864
|
+
/** Format: uint64 */
|
|
865
|
+
chunks_sent: number;
|
|
866
|
+
/** Format: uint64 */
|
|
867
|
+
decoy_down: number;
|
|
868
|
+
/** Format: uint */
|
|
869
|
+
decoys: number;
|
|
870
|
+
/** Format: uint64 */
|
|
871
|
+
ended_closed: number;
|
|
872
|
+
/**
|
|
873
|
+
* Format: uint64
|
|
874
|
+
* @description Sessions that ended, by reason: no WireGuard packet within 10 seconds of the proof, no chunk for 300 seconds, every chunk number used, the device's ninth session, a device or transport secret the config no longer has, a connection that closed or a peer that closed the session, a chunk that did not open or a frame the protocol does not allow, and a transport the config no longer has.
|
|
875
|
+
*/
|
|
876
|
+
ended_deadline: number;
|
|
877
|
+
/** Format: uint64 */
|
|
878
|
+
ended_displaced: number;
|
|
879
|
+
/** Format: uint64 */
|
|
880
|
+
ended_idle: number;
|
|
881
|
+
/** Format: uint64 */
|
|
882
|
+
ended_invalid: number;
|
|
883
|
+
/** Format: uint64 */
|
|
884
|
+
ended_packets: number;
|
|
885
|
+
/** Format: uint64 */
|
|
886
|
+
ended_revoked: number;
|
|
887
|
+
/** Format: uint64 */
|
|
888
|
+
ended_unserved: number;
|
|
889
|
+
/** Format: uint64 */
|
|
890
|
+
establish_full: number;
|
|
891
|
+
/** Format: uint64 */
|
|
892
|
+
established: number;
|
|
893
|
+
/**
|
|
894
|
+
* Format: uint64
|
|
895
|
+
* @description Requests handed to a decoy origin on the proxy path. `forwards_unframed` are those of them the node could not tell the end of, which it relayed to the end of the origin's answer and then closed the proxy's connection behind. `forwards_cut` are connections closed at once because one source had more than its share of requests waiting, or all strangers together more than half the proxy pool.
|
|
896
|
+
*/
|
|
897
|
+
forwards: number;
|
|
898
|
+
/** Format: uint64 */
|
|
899
|
+
forwards_cut: number;
|
|
900
|
+
/**
|
|
901
|
+
* Format: uint64
|
|
902
|
+
* @description Requests that were sent to a decoy origin once more on a new connection, because the connection kept from the request before had been closed by the origin. `origin_dropped` are connections to a decoy origin that the node dropped between two requests because the origin said something or closed them there: nothing of that is passed on to the proxy.
|
|
903
|
+
*/
|
|
904
|
+
forwards_redialed: number;
|
|
905
|
+
/** Format: uint64 */
|
|
906
|
+
forwards_unframed: number;
|
|
907
|
+
/** Format: uint */
|
|
908
|
+
fronted: number;
|
|
909
|
+
/** Format: uint64 */
|
|
910
|
+
handshake_displaced: number;
|
|
911
|
+
/**
|
|
912
|
+
* Format: uint64
|
|
913
|
+
* @description TLS handshakes that failed, that did not finish within 10 seconds, and that were closed to make room in the undecided pool.
|
|
914
|
+
*/
|
|
915
|
+
handshake_failed: number;
|
|
916
|
+
/** Format: uint64 */
|
|
917
|
+
handshake_slow: number;
|
|
918
|
+
/**
|
|
919
|
+
* Format: uint64
|
|
920
|
+
* @description Inside sessions: handshake initiations above a session's allowance, datagrams WireGuard did not take as a packet of the session's device, datagrams for a device that were dropped because the send queue of its connection held 256, and chunks the node sent.
|
|
921
|
+
*/
|
|
922
|
+
handshakes: number;
|
|
923
|
+
/** Format: uint64 */
|
|
924
|
+
head_refused: number;
|
|
925
|
+
/** Format: uint64 */
|
|
926
|
+
origin_dropped: number;
|
|
927
|
+
/**
|
|
928
|
+
* Format: uint
|
|
929
|
+
* @description Sessions whose proof was accepted and on which WireGuard has not authenticated yet, right now.
|
|
930
|
+
*/
|
|
931
|
+
pending: number;
|
|
932
|
+
/** Format: uint64 */
|
|
933
|
+
poll_repeats: number;
|
|
934
|
+
/**
|
|
935
|
+
* Format: uint64
|
|
936
|
+
* @description `fronted` requests that were accepted, and repeats of the last accepted request that were answered with the stored response.
|
|
937
|
+
*/
|
|
938
|
+
polls: number;
|
|
939
|
+
/**
|
|
940
|
+
* Format: uint64
|
|
941
|
+
* @description Proofs that were accepted, proofs that waited for the write of a higher limit, users whose request head was over a limit or no WebSocket upgrade, sessions that became established, and sessions that could not because the session pool had filled up since their proof.
|
|
942
|
+
*/
|
|
943
|
+
proofs_accepted: number;
|
|
944
|
+
/** Format: uint64 */
|
|
945
|
+
proofs_waited: number;
|
|
946
|
+
/**
|
|
947
|
+
* Format: uint
|
|
948
|
+
* @description The proxy path of the `ws` and `fronted` listeners, right now: connections of trusted proxies, requests on them that are in a decoy origin's hands or whose body is still read with nothing proven, and established `fronted` sessions.
|
|
949
|
+
*/
|
|
950
|
+
proxies: number;
|
|
951
|
+
/**
|
|
952
|
+
* Format: uint64
|
|
953
|
+
* @description Connections taken from a trusted proxy, and requests read on them. `proxy_unnamed` are those of them, on a listener with a `client_address_header`, in which that header named no source: the proxy itself stood for the visitor, so the limits per source were one limit for all of them. `proxy_idle` are connections closed after 300 seconds without a request.
|
|
954
|
+
*/
|
|
955
|
+
proxy_accepted: number;
|
|
956
|
+
/**
|
|
957
|
+
* Format: uint64
|
|
958
|
+
* @description Requests of trusted proxies that were HTTP/1.0. None of them can be a user's: a web server that speaks HTTP/1.0 to the node shuts every user out, and has to be told to speak HTTP/1.1.
|
|
959
|
+
*/
|
|
960
|
+
proxy_http10: number;
|
|
961
|
+
/** Format: uint64 */
|
|
962
|
+
proxy_idle: number;
|
|
963
|
+
/** Format: uint64 */
|
|
964
|
+
proxy_requests: number;
|
|
965
|
+
/** Format: uint64 */
|
|
966
|
+
proxy_unnamed: number;
|
|
967
|
+
/** Format: uint64 */
|
|
968
|
+
queue_full: number;
|
|
969
|
+
/** Format: uint64 */
|
|
970
|
+
refused_cache_full: number;
|
|
971
|
+
/** Format: uint64 */
|
|
972
|
+
refused_device_rate: number;
|
|
973
|
+
/** Format: uint64 */
|
|
974
|
+
refused_floor: number;
|
|
975
|
+
/**
|
|
976
|
+
* Format: uint64
|
|
977
|
+
* @description A timestamp above the written limit whose write did not end within 2 seconds or for which 64 other proofs waited already, and proofs that came while the node took none at all.
|
|
978
|
+
*/
|
|
979
|
+
refused_limit: number;
|
|
980
|
+
/** Format: uint64 */
|
|
981
|
+
refused_no_replay: number;
|
|
982
|
+
/** Format: uint64 */
|
|
983
|
+
refused_pending: number;
|
|
984
|
+
/**
|
|
985
|
+
* Format: uint64
|
|
986
|
+
* @description By a limit: the listener's session pool is full, the device has 2 pending sessions, or the device's or the source's allowance of accepted proofs is spent.
|
|
987
|
+
*/
|
|
988
|
+
refused_pool: number;
|
|
989
|
+
/** Format: uint64 */
|
|
990
|
+
refused_seen: number;
|
|
991
|
+
/** Format: uint64 */
|
|
992
|
+
refused_source_rate: number;
|
|
993
|
+
/**
|
|
994
|
+
* Format: uint64
|
|
995
|
+
* @description Proofs of a device that were refused all the same, each of which took the decoy path too. By the replay rule: a timestamp outside the window of 60 seconds, at or below the floor, a token that was accepted before, and any while the cache is full.
|
|
996
|
+
*/
|
|
997
|
+
refused_window: number;
|
|
998
|
+
/**
|
|
999
|
+
* Format: uint
|
|
1000
|
+
* @description Connections that are relayed to a decoy origin right now.
|
|
1001
|
+
*/
|
|
1002
|
+
relayed: number;
|
|
1003
|
+
/**
|
|
1004
|
+
* Format: uint64
|
|
1005
|
+
* @description Connections that were connected to a decoy origin and relayed, relayed connections that were closed to make room for another, and strangers that were closed with no answer because the origin could not be reached. While `decoy_down` grows the node can be told from its decoy.
|
|
1006
|
+
*/
|
|
1007
|
+
relays: number;
|
|
1008
|
+
/** Format: uint64 */
|
|
1009
|
+
relays_evicted: number;
|
|
1010
|
+
/**
|
|
1011
|
+
* Format: uint
|
|
1012
|
+
* @description Established sessions right now.
|
|
1013
|
+
*/
|
|
1014
|
+
sessions: number;
|
|
1015
|
+
/** Format: uint64 */
|
|
1016
|
+
stranger_body: number;
|
|
1017
|
+
/** Format: uint64 */
|
|
1018
|
+
stranger_closed: number;
|
|
1019
|
+
/** Format: uint64 */
|
|
1020
|
+
stranger_displaced: number;
|
|
1021
|
+
/**
|
|
1022
|
+
* Format: uint64
|
|
1023
|
+
* @description Requests of the proxy path decided "not a user" for a reason only that path has: a head above 16,384 bytes or not complete within 10 seconds, a `fronted` request that names a session with a number out of order or while another request of it is in flight, one whose body was late, did not open or was a repeat with other bytes, and an opening request whose session no WireGuard packet established.
|
|
1024
|
+
*/
|
|
1025
|
+
stranger_head: number;
|
|
1026
|
+
/** Format: uint64 */
|
|
1027
|
+
stranger_origin: number;
|
|
1028
|
+
/** Format: uint64 */
|
|
1029
|
+
stranger_proof: number;
|
|
1030
|
+
/** Format: uint64 */
|
|
1031
|
+
stranger_session: number;
|
|
1032
|
+
/** Format: uint64 */
|
|
1033
|
+
stranger_slow: number;
|
|
1034
|
+
/**
|
|
1035
|
+
* Format: uint64
|
|
1036
|
+
* @description Connections decided "not a user", by the class of the reason: a byte that cannot be part of a user's request line or a line above 4,096 bytes, `stranger_syntax`. A line that was not complete within 10 seconds, `stranger_slow`. A peer that closed its side first, `stranger_closed`. A connection decided at once to make room in the undecided pool, `stranger_displaced`. A connection whose decoy origin said something or closed while the request line was not complete, `stranger_origin`. A complete request line that is no proof of a device, `stranger_proof`, which is where a wrong path, a wrong token and a removed device are counted alike.
|
|
1037
|
+
*/
|
|
1038
|
+
stranger_syntax: number;
|
|
1039
|
+
/** Format: uint64 */
|
|
1040
|
+
stranger_unestablished: number;
|
|
1041
|
+
/** Format: uint64 */
|
|
1042
|
+
tunnel: number;
|
|
1043
|
+
/**
|
|
1044
|
+
* Format: uint
|
|
1045
|
+
* @description Connections that have not been decided yet, right now: inside their TLS handshake or their request line.
|
|
1046
|
+
*/
|
|
1047
|
+
undecided: number;
|
|
1048
|
+
/** Format: uint64 */
|
|
1049
|
+
upgrade_learn_failed: number;
|
|
1050
|
+
/**
|
|
1051
|
+
* Format: uint64
|
|
1052
|
+
* @description How often the header fields of the upgrade answer were learnt from a decoy origin, and how often that failed. While the last try failed, the upgrade answer carries only `Date` of `upgrade_headers`.
|
|
1053
|
+
*/
|
|
1054
|
+
upgrade_learned: number;
|
|
1055
|
+
};
|
|
1056
|
+
/** @description Inner IP packets and their bytes since the node first knew the name. Up is from the device into the node. */
|
|
1057
|
+
Traffic: {
|
|
1058
|
+
/** Format: uint64 */
|
|
1059
|
+
down_bytes: number;
|
|
1060
|
+
/** Format: uint64 */
|
|
1061
|
+
down_packets: number;
|
|
1062
|
+
/** Format: uint64 */
|
|
1063
|
+
up_bytes: number;
|
|
1064
|
+
/** Format: uint64 */
|
|
1065
|
+
up_packets: number;
|
|
1066
|
+
};
|
|
1067
|
+
/**
|
|
1068
|
+
* @description The transport a device came over, as the config names it: `ws` is the relay of a `wireguard` inbound, and on a `veilway` inbound the native WebSocket session behind the operator's web server.
|
|
1069
|
+
* @enum {string}
|
|
1070
|
+
*/
|
|
1071
|
+
Transport: "udp" | "ws" | "udp-obfs" | "tls" | "fronted";
|
|
1072
|
+
/** @description What the `udp-obfs` transports did since start, and what they hold right now. Everything but `pending`, `sessions` and `tags` only grows. A datagram that is dropped gets no answer whatever the reason, and no reason holds an address, a tag or a key. */
|
|
1073
|
+
UdpObfs: {
|
|
1074
|
+
/** Format: uint64 */
|
|
1075
|
+
cache_full: number;
|
|
1076
|
+
/** Format: uint64 */
|
|
1077
|
+
device_rate: number;
|
|
1078
|
+
/**
|
|
1079
|
+
* Format: uint64
|
|
1080
|
+
* @description Sessions that ended, by reason: no WireGuard packet within 10 seconds of the opening packet, no activity for 180 seconds, 2^31 packets sent, a newer session of the same source and device, the device's ninth session, and a device or transport secret the config no longer has.
|
|
1081
|
+
*/
|
|
1082
|
+
ended_deadline: number;
|
|
1083
|
+
/** Format: uint64 */
|
|
1084
|
+
ended_displaced: number;
|
|
1085
|
+
/** Format: uint64 */
|
|
1086
|
+
ended_idle: number;
|
|
1087
|
+
/** Format: uint64 */
|
|
1088
|
+
ended_packets: number;
|
|
1089
|
+
/** Format: uint64 */
|
|
1090
|
+
ended_replaced: number;
|
|
1091
|
+
/** Format: uint64 */
|
|
1092
|
+
ended_revoked: number;
|
|
1093
|
+
/** Format: uint64 */
|
|
1094
|
+
established: number;
|
|
1095
|
+
/** Format: uint64 */
|
|
1096
|
+
floor: number;
|
|
1097
|
+
/**
|
|
1098
|
+
* Format: uint64
|
|
1099
|
+
* @description Handshake initiations above a session's allowance, datagrams inside a session that WireGuard did not take as a packet of the session's device, and packets the node could not make.
|
|
1100
|
+
*/
|
|
1101
|
+
handshakes: number;
|
|
1102
|
+
/**
|
|
1103
|
+
* Format: uint64
|
|
1104
|
+
* @description Opening packets with a timestamp above the written limit that were dropped: the listener already kept 64 others, or no write ended within 2 seconds. And those that came while the node took no proof at all.
|
|
1105
|
+
*/
|
|
1106
|
+
limit: number;
|
|
1107
|
+
/** Format: uint64 */
|
|
1108
|
+
no_replay: number;
|
|
1109
|
+
/** Format: uint64 */
|
|
1110
|
+
open_failed: number;
|
|
1111
|
+
/**
|
|
1112
|
+
* Format: uint64
|
|
1113
|
+
* @description Opening packets that were accepted, and sessions that became established.
|
|
1114
|
+
*/
|
|
1115
|
+
opened: number;
|
|
1116
|
+
/**
|
|
1117
|
+
* Format: uint
|
|
1118
|
+
* @description Sessions whose opening packet was accepted and on which WireGuard has not authenticated yet, right now.
|
|
1119
|
+
*/
|
|
1120
|
+
pending: number;
|
|
1121
|
+
/** Format: uint64 */
|
|
1122
|
+
pending_full: number;
|
|
1123
|
+
/** Format: uint64 */
|
|
1124
|
+
pool: number;
|
|
1125
|
+
/** Format: uint64 */
|
|
1126
|
+
seen: number;
|
|
1127
|
+
/**
|
|
1128
|
+
* Format: uint64
|
|
1129
|
+
* @description Packets the listeners made for a socket. Every one is a data packet of an established session, so a node that only strangers talk to has 0 here.
|
|
1130
|
+
*/
|
|
1131
|
+
sent: number;
|
|
1132
|
+
/**
|
|
1133
|
+
* Format: uint
|
|
1134
|
+
* @description Established sessions right now, with those that a newer session of the same source replaced and that are still readable for 10 seconds.
|
|
1135
|
+
*/
|
|
1136
|
+
sessions: number;
|
|
1137
|
+
/**
|
|
1138
|
+
* Format: uint64
|
|
1139
|
+
* @description Datagrams dropped, by reason: shorter than a data packet, `short`. No data packet of a session at its source and a tag that is not in the tag table, `unknown`, which is where every datagram of a stranger is counted. A tag that is in the table on a packet that does not open, `open_failed`: its sender holds a tag of this epoch without the device's secret, or the packet was changed on its way.
|
|
1140
|
+
*/
|
|
1141
|
+
short: number;
|
|
1142
|
+
/**
|
|
1143
|
+
* Format: uint64
|
|
1144
|
+
* @description Opening packets refused by a limit: the source has sessions of 4 other devices, the listener's session pool is full, the device has 2 pending sessions, or the device's or the source's allowance of accepted proofs is spent.
|
|
1145
|
+
*/
|
|
1146
|
+
source_devices: number;
|
|
1147
|
+
/** Format: uint64 */
|
|
1148
|
+
source_rate: number;
|
|
1149
|
+
/** Format: uint64 */
|
|
1150
|
+
spent: number;
|
|
1151
|
+
/** Format: uint64 */
|
|
1152
|
+
table_build_failures: number;
|
|
1153
|
+
/**
|
|
1154
|
+
* Format: uint64
|
|
1155
|
+
* @description How often a tag table was built for a new epoch, how often that was late, how often a build did not end, and tags that were left out because another secret had the same.
|
|
1156
|
+
*/
|
|
1157
|
+
table_rebuilds: number;
|
|
1158
|
+
/** Format: uint64 */
|
|
1159
|
+
table_rebuilds_late: number;
|
|
1160
|
+
/** Format: uint64 */
|
|
1161
|
+
tag_collisions: number;
|
|
1162
|
+
/**
|
|
1163
|
+
* Format: uint
|
|
1164
|
+
* @description Epoch tags in the tag tables right now: three for each transport secret of each device that may connect.
|
|
1165
|
+
*/
|
|
1166
|
+
tags: number;
|
|
1167
|
+
/** Format: uint64 */
|
|
1168
|
+
tunnel: number;
|
|
1169
|
+
/** Format: uint64 */
|
|
1170
|
+
unknown: number;
|
|
1171
|
+
/** Format: uint64 */
|
|
1172
|
+
unsendable: number;
|
|
1173
|
+
/**
|
|
1174
|
+
* Format: uint64
|
|
1175
|
+
* @description Opening packets that were kept for the write of a higher limit and taken to the replay rule again when it had ended, and opening packets a limit refused whose salt was recorded as spent, so that nobody who saw one can use it later.
|
|
1176
|
+
*/
|
|
1177
|
+
waited: number;
|
|
1178
|
+
/**
|
|
1179
|
+
* Format: uint64
|
|
1180
|
+
* @description Opening packets of a device that the replay rule refused: a timestamp outside the window of 60 seconds, at or below the floor, a packet that was accepted before, and any while the cache is full.
|
|
1181
|
+
*/
|
|
1182
|
+
window: number;
|
|
1183
|
+
};
|
|
1184
|
+
/** @description The data of a `usage_reset` event: the user's quota count was started over through the API, and with `totals` their traffic counters went back to zero as well. A user who was out of quota gets a `user_restored` right behind it. */
|
|
1185
|
+
UsageReset: {
|
|
1186
|
+
totals: boolean;
|
|
1187
|
+
user: string;
|
|
1188
|
+
};
|
|
1189
|
+
User: {
|
|
1190
|
+
/** @description Why the user cannot connect right now. Null for a user who can. */
|
|
1191
|
+
denied: components["schemas"]["Denied"] | null;
|
|
1192
|
+
devices: components["schemas"]["Device"][];
|
|
1193
|
+
/** @description The tag of the DNS set that names the user, or else one of their groups. Null when no set does: the user's queries then go to the set that names the inbound they come through, or to `dns.servers`. */
|
|
1194
|
+
dns_set: string | null;
|
|
1195
|
+
enabled: boolean;
|
|
1196
|
+
expires_at: string | null;
|
|
1197
|
+
name: string;
|
|
1198
|
+
/**
|
|
1199
|
+
* Format: int64
|
|
1200
|
+
* @description When the count last started over, in Unix seconds. 0 for a user who never had a `quota_period`, or who had none when their usage was last reset.
|
|
1201
|
+
*/
|
|
1202
|
+
period_start: number;
|
|
1203
|
+
/** Format: uint64 */
|
|
1204
|
+
quota_bytes: number | null;
|
|
1205
|
+
quota_period: components["schemas"]["QuotaPeriod"] | null;
|
|
1206
|
+
traffic: components["schemas"]["Traffic"];
|
|
1207
|
+
/**
|
|
1208
|
+
* Format: uint64
|
|
1209
|
+
* @description Bytes in both directions since `period_start`, which is what `quota_bytes` is held against.
|
|
1210
|
+
*/
|
|
1211
|
+
used_bytes: number;
|
|
1212
|
+
};
|
|
1213
|
+
/** @description Devices are named by their public key. */
|
|
1214
|
+
UserChange: {
|
|
1215
|
+
devices_added: string[];
|
|
1216
|
+
devices_readdressed: string[];
|
|
1217
|
+
devices_rekeyed: string[];
|
|
1218
|
+
devices_removed: string[];
|
|
1219
|
+
/** @description Kept devices whose transport secrets changed. */
|
|
1220
|
+
devices_secrets_changed: string[];
|
|
1221
|
+
/** @description The user could connect and no longer can. */
|
|
1222
|
+
lost_access: boolean;
|
|
1223
|
+
name: string;
|
|
1224
|
+
};
|
|
1225
|
+
/** @description The data of a `user_cut_off` event. */
|
|
1226
|
+
UserCutOff: {
|
|
1227
|
+
reason: components["schemas"]["Reason"];
|
|
1228
|
+
user: string;
|
|
1229
|
+
};
|
|
1230
|
+
/** @description The data of a `user_restored` event. */
|
|
1231
|
+
UserRestored: {
|
|
1232
|
+
user: string;
|
|
1233
|
+
};
|
|
1234
|
+
Users: {
|
|
1235
|
+
users: components["schemas"]["User"][];
|
|
1236
|
+
};
|
|
1237
|
+
Validation: {
|
|
1238
|
+
report: components["schemas"]["Report"];
|
|
1239
|
+
valid: boolean;
|
|
1240
|
+
};
|
|
1241
|
+
XrayAddon: {
|
|
1242
|
+
/** @description Whether the add-on's executable is in the add-on folder. */
|
|
1243
|
+
installed: boolean;
|
|
1244
|
+
/** @description The release of Xray-core this node runs. */
|
|
1245
|
+
release: string;
|
|
1246
|
+
};
|
|
1247
|
+
};
|
|
1248
|
+
responses: never;
|
|
1249
|
+
parameters: never;
|
|
1250
|
+
requestBodies: never;
|
|
1251
|
+
headers: never;
|
|
1252
|
+
pathItems: never;
|
|
1253
|
+
}
|
|
1254
|
+
export type $defs = Record<string, never>;
|
|
1255
|
+
export interface operations {
|
|
1256
|
+
getConfig: {
|
|
1257
|
+
parameters: {
|
|
1258
|
+
query?: never;
|
|
1259
|
+
header?: never;
|
|
1260
|
+
path?: never;
|
|
1261
|
+
cookie?: never;
|
|
1262
|
+
};
|
|
1263
|
+
requestBody?: never;
|
|
1264
|
+
responses: {
|
|
1265
|
+
/** @description The answer. */
|
|
1266
|
+
200: {
|
|
1267
|
+
headers: {
|
|
1268
|
+
[name: string]: unknown;
|
|
1269
|
+
};
|
|
1270
|
+
content: {
|
|
1271
|
+
"application/json": components["schemas"]["Running"];
|
|
1272
|
+
};
|
|
1273
|
+
};
|
|
1274
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1275
|
+
408: {
|
|
1276
|
+
headers: {
|
|
1277
|
+
[name: string]: unknown;
|
|
1278
|
+
};
|
|
1279
|
+
content: {
|
|
1280
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1281
|
+
};
|
|
1282
|
+
};
|
|
1283
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1284
|
+
503: {
|
|
1285
|
+
headers: {
|
|
1286
|
+
[name: string]: unknown;
|
|
1287
|
+
};
|
|
1288
|
+
content: {
|
|
1289
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1290
|
+
};
|
|
1291
|
+
};
|
|
1292
|
+
};
|
|
1293
|
+
};
|
|
1294
|
+
applyConfig: {
|
|
1295
|
+
parameters: {
|
|
1296
|
+
query?: never;
|
|
1297
|
+
header: {
|
|
1298
|
+
/** @description The revision of the config the change was made on, as GET /v1/config gave it, with or without quotes. */
|
|
1299
|
+
"If-Match": string;
|
|
1300
|
+
};
|
|
1301
|
+
path?: never;
|
|
1302
|
+
cookie?: never;
|
|
1303
|
+
};
|
|
1304
|
+
requestBody: {
|
|
1305
|
+
content: {
|
|
1306
|
+
"application/json": components["schemas"]["Document"];
|
|
1307
|
+
};
|
|
1308
|
+
};
|
|
1309
|
+
responses: {
|
|
1310
|
+
/** @description The answer. */
|
|
1311
|
+
200: {
|
|
1312
|
+
headers: {
|
|
1313
|
+
[name: string]: unknown;
|
|
1314
|
+
};
|
|
1315
|
+
content: {
|
|
1316
|
+
"application/json": components["schemas"]["Applied"];
|
|
1317
|
+
};
|
|
1318
|
+
};
|
|
1319
|
+
/** @description The body is not one JSON document, or could not be read to its end. */
|
|
1320
|
+
400: {
|
|
1321
|
+
headers: {
|
|
1322
|
+
[name: string]: unknown;
|
|
1323
|
+
};
|
|
1324
|
+
content: {
|
|
1325
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1326
|
+
};
|
|
1327
|
+
};
|
|
1328
|
+
/** @description The document was not read and checked within 30 seconds. Nothing was changed: once the node has begun to put a config in force, the answer waits for it however long that takes, and is never this one. */
|
|
1329
|
+
408: {
|
|
1330
|
+
headers: {
|
|
1331
|
+
[name: string]: unknown;
|
|
1332
|
+
};
|
|
1333
|
+
content: {
|
|
1334
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1335
|
+
};
|
|
1336
|
+
};
|
|
1337
|
+
/** @description The running config is not the one If-Match names. The details and the ETag hold the revision that runs. */
|
|
1338
|
+
409: {
|
|
1339
|
+
headers: {
|
|
1340
|
+
[name: string]: unknown;
|
|
1341
|
+
};
|
|
1342
|
+
content: {
|
|
1343
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1344
|
+
};
|
|
1345
|
+
};
|
|
1346
|
+
/** @description The body is larger than 4 MiB. */
|
|
1347
|
+
413: {
|
|
1348
|
+
headers: {
|
|
1349
|
+
[name: string]: unknown;
|
|
1350
|
+
};
|
|
1351
|
+
content: {
|
|
1352
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1353
|
+
};
|
|
1354
|
+
};
|
|
1355
|
+
/** @description The body was not sent as application/json. */
|
|
1356
|
+
415: {
|
|
1357
|
+
headers: {
|
|
1358
|
+
[name: string]: unknown;
|
|
1359
|
+
};
|
|
1360
|
+
content: {
|
|
1361
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1362
|
+
};
|
|
1363
|
+
};
|
|
1364
|
+
/** @description The document is not a valid config, or the node could not prepare it. Nothing was changed. */
|
|
1365
|
+
422: {
|
|
1366
|
+
headers: {
|
|
1367
|
+
[name: string]: unknown;
|
|
1368
|
+
};
|
|
1369
|
+
content: {
|
|
1370
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1371
|
+
};
|
|
1372
|
+
};
|
|
1373
|
+
/** @description The header If-Match is missing. */
|
|
1374
|
+
428: {
|
|
1375
|
+
headers: {
|
|
1376
|
+
[name: string]: unknown;
|
|
1377
|
+
};
|
|
1378
|
+
content: {
|
|
1379
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1380
|
+
};
|
|
1381
|
+
};
|
|
1382
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1383
|
+
503: {
|
|
1384
|
+
headers: {
|
|
1385
|
+
[name: string]: unknown;
|
|
1386
|
+
};
|
|
1387
|
+
content: {
|
|
1388
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1389
|
+
};
|
|
1390
|
+
};
|
|
1391
|
+
};
|
|
1392
|
+
};
|
|
1393
|
+
diffConfig: {
|
|
1394
|
+
parameters: {
|
|
1395
|
+
query?: never;
|
|
1396
|
+
header?: never;
|
|
1397
|
+
path?: never;
|
|
1398
|
+
cookie?: never;
|
|
1399
|
+
};
|
|
1400
|
+
requestBody: {
|
|
1401
|
+
content: {
|
|
1402
|
+
"application/json": components["schemas"]["Document"];
|
|
1403
|
+
};
|
|
1404
|
+
};
|
|
1405
|
+
responses: {
|
|
1406
|
+
/** @description The answer. */
|
|
1407
|
+
200: {
|
|
1408
|
+
headers: {
|
|
1409
|
+
[name: string]: unknown;
|
|
1410
|
+
};
|
|
1411
|
+
content: {
|
|
1412
|
+
"application/json": components["schemas"]["Difference"];
|
|
1413
|
+
};
|
|
1414
|
+
};
|
|
1415
|
+
/** @description The body is not one JSON document, or could not be read to its end. */
|
|
1416
|
+
400: {
|
|
1417
|
+
headers: {
|
|
1418
|
+
[name: string]: unknown;
|
|
1419
|
+
};
|
|
1420
|
+
content: {
|
|
1421
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1422
|
+
};
|
|
1423
|
+
};
|
|
1424
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1425
|
+
408: {
|
|
1426
|
+
headers: {
|
|
1427
|
+
[name: string]: unknown;
|
|
1428
|
+
};
|
|
1429
|
+
content: {
|
|
1430
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1431
|
+
};
|
|
1432
|
+
};
|
|
1433
|
+
/** @description The body is larger than 4 MiB. */
|
|
1434
|
+
413: {
|
|
1435
|
+
headers: {
|
|
1436
|
+
[name: string]: unknown;
|
|
1437
|
+
};
|
|
1438
|
+
content: {
|
|
1439
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1440
|
+
};
|
|
1441
|
+
};
|
|
1442
|
+
/** @description The body was not sent as application/json. */
|
|
1443
|
+
415: {
|
|
1444
|
+
headers: {
|
|
1445
|
+
[name: string]: unknown;
|
|
1446
|
+
};
|
|
1447
|
+
content: {
|
|
1448
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1449
|
+
};
|
|
1450
|
+
};
|
|
1451
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1452
|
+
503: {
|
|
1453
|
+
headers: {
|
|
1454
|
+
[name: string]: unknown;
|
|
1455
|
+
};
|
|
1456
|
+
content: {
|
|
1457
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1458
|
+
};
|
|
1459
|
+
};
|
|
1460
|
+
};
|
|
1461
|
+
};
|
|
1462
|
+
validateConfig: {
|
|
1463
|
+
parameters: {
|
|
1464
|
+
query?: never;
|
|
1465
|
+
header?: never;
|
|
1466
|
+
path?: never;
|
|
1467
|
+
cookie?: never;
|
|
1468
|
+
};
|
|
1469
|
+
requestBody: {
|
|
1470
|
+
content: {
|
|
1471
|
+
"application/json": components["schemas"]["Document"];
|
|
1472
|
+
};
|
|
1473
|
+
};
|
|
1474
|
+
responses: {
|
|
1475
|
+
/** @description The answer. */
|
|
1476
|
+
200: {
|
|
1477
|
+
headers: {
|
|
1478
|
+
[name: string]: unknown;
|
|
1479
|
+
};
|
|
1480
|
+
content: {
|
|
1481
|
+
"application/json": components["schemas"]["Validation"];
|
|
1482
|
+
};
|
|
1483
|
+
};
|
|
1484
|
+
/** @description The body is not one JSON document, or could not be read to its end. */
|
|
1485
|
+
400: {
|
|
1486
|
+
headers: {
|
|
1487
|
+
[name: string]: unknown;
|
|
1488
|
+
};
|
|
1489
|
+
content: {
|
|
1490
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1491
|
+
};
|
|
1492
|
+
};
|
|
1493
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1494
|
+
408: {
|
|
1495
|
+
headers: {
|
|
1496
|
+
[name: string]: unknown;
|
|
1497
|
+
};
|
|
1498
|
+
content: {
|
|
1499
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1500
|
+
};
|
|
1501
|
+
};
|
|
1502
|
+
/** @description The body is larger than 4 MiB. */
|
|
1503
|
+
413: {
|
|
1504
|
+
headers: {
|
|
1505
|
+
[name: string]: unknown;
|
|
1506
|
+
};
|
|
1507
|
+
content: {
|
|
1508
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1509
|
+
};
|
|
1510
|
+
};
|
|
1511
|
+
/** @description The body was not sent as application/json. */
|
|
1512
|
+
415: {
|
|
1513
|
+
headers: {
|
|
1514
|
+
[name: string]: unknown;
|
|
1515
|
+
};
|
|
1516
|
+
content: {
|
|
1517
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1518
|
+
};
|
|
1519
|
+
};
|
|
1520
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1521
|
+
503: {
|
|
1522
|
+
headers: {
|
|
1523
|
+
[name: string]: unknown;
|
|
1524
|
+
};
|
|
1525
|
+
content: {
|
|
1526
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1527
|
+
};
|
|
1528
|
+
};
|
|
1529
|
+
};
|
|
1530
|
+
};
|
|
1531
|
+
events: {
|
|
1532
|
+
parameters: {
|
|
1533
|
+
query?: never;
|
|
1534
|
+
header?: never;
|
|
1535
|
+
path?: never;
|
|
1536
|
+
cookie?: never;
|
|
1537
|
+
};
|
|
1538
|
+
requestBody?: never;
|
|
1539
|
+
responses: {
|
|
1540
|
+
/** @description The stream. The data of each event is one JSON document, see x-events. */
|
|
1541
|
+
200: {
|
|
1542
|
+
headers: {
|
|
1543
|
+
[name: string]: unknown;
|
|
1544
|
+
};
|
|
1545
|
+
content: {
|
|
1546
|
+
"text/event-stream": string;
|
|
1547
|
+
};
|
|
1548
|
+
};
|
|
1549
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1550
|
+
408: {
|
|
1551
|
+
headers: {
|
|
1552
|
+
[name: string]: unknown;
|
|
1553
|
+
};
|
|
1554
|
+
content: {
|
|
1555
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1556
|
+
};
|
|
1557
|
+
};
|
|
1558
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1559
|
+
503: {
|
|
1560
|
+
headers: {
|
|
1561
|
+
[name: string]: unknown;
|
|
1562
|
+
};
|
|
1563
|
+
content: {
|
|
1564
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1565
|
+
};
|
|
1566
|
+
};
|
|
1567
|
+
};
|
|
1568
|
+
};
|
|
1569
|
+
listExits: {
|
|
1570
|
+
parameters: {
|
|
1571
|
+
query?: never;
|
|
1572
|
+
header?: never;
|
|
1573
|
+
path?: never;
|
|
1574
|
+
cookie?: never;
|
|
1575
|
+
};
|
|
1576
|
+
requestBody?: never;
|
|
1577
|
+
responses: {
|
|
1578
|
+
/** @description The answer. */
|
|
1579
|
+
200: {
|
|
1580
|
+
headers: {
|
|
1581
|
+
[name: string]: unknown;
|
|
1582
|
+
};
|
|
1583
|
+
content: {
|
|
1584
|
+
"application/json": components["schemas"]["Exits"];
|
|
1585
|
+
};
|
|
1586
|
+
};
|
|
1587
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1588
|
+
408: {
|
|
1589
|
+
headers: {
|
|
1590
|
+
[name: string]: unknown;
|
|
1591
|
+
};
|
|
1592
|
+
content: {
|
|
1593
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1594
|
+
};
|
|
1595
|
+
};
|
|
1596
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1597
|
+
503: {
|
|
1598
|
+
headers: {
|
|
1599
|
+
[name: string]: unknown;
|
|
1600
|
+
};
|
|
1601
|
+
content: {
|
|
1602
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1603
|
+
};
|
|
1604
|
+
};
|
|
1605
|
+
};
|
|
1606
|
+
};
|
|
1607
|
+
listInbounds: {
|
|
1608
|
+
parameters: {
|
|
1609
|
+
query?: never;
|
|
1610
|
+
header?: never;
|
|
1611
|
+
path?: never;
|
|
1612
|
+
cookie?: never;
|
|
1613
|
+
};
|
|
1614
|
+
requestBody?: never;
|
|
1615
|
+
responses: {
|
|
1616
|
+
/** @description The answer. */
|
|
1617
|
+
200: {
|
|
1618
|
+
headers: {
|
|
1619
|
+
[name: string]: unknown;
|
|
1620
|
+
};
|
|
1621
|
+
content: {
|
|
1622
|
+
"application/json": components["schemas"]["Inbounds"];
|
|
1623
|
+
};
|
|
1624
|
+
};
|
|
1625
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1626
|
+
408: {
|
|
1627
|
+
headers: {
|
|
1628
|
+
[name: string]: unknown;
|
|
1629
|
+
};
|
|
1630
|
+
content: {
|
|
1631
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1632
|
+
};
|
|
1633
|
+
};
|
|
1634
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1635
|
+
503: {
|
|
1636
|
+
headers: {
|
|
1637
|
+
[name: string]: unknown;
|
|
1638
|
+
};
|
|
1639
|
+
content: {
|
|
1640
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1641
|
+
};
|
|
1642
|
+
};
|
|
1643
|
+
};
|
|
1644
|
+
};
|
|
1645
|
+
listLinks: {
|
|
1646
|
+
parameters: {
|
|
1647
|
+
query?: never;
|
|
1648
|
+
header?: never;
|
|
1649
|
+
path?: never;
|
|
1650
|
+
cookie?: never;
|
|
1651
|
+
};
|
|
1652
|
+
requestBody?: never;
|
|
1653
|
+
responses: {
|
|
1654
|
+
/** @description The answer. */
|
|
1655
|
+
200: {
|
|
1656
|
+
headers: {
|
|
1657
|
+
[name: string]: unknown;
|
|
1658
|
+
};
|
|
1659
|
+
content: {
|
|
1660
|
+
"application/json": components["schemas"]["Links"];
|
|
1661
|
+
};
|
|
1662
|
+
};
|
|
1663
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1664
|
+
408: {
|
|
1665
|
+
headers: {
|
|
1666
|
+
[name: string]: unknown;
|
|
1667
|
+
};
|
|
1668
|
+
content: {
|
|
1669
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1670
|
+
};
|
|
1671
|
+
};
|
|
1672
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1673
|
+
503: {
|
|
1674
|
+
headers: {
|
|
1675
|
+
[name: string]: unknown;
|
|
1676
|
+
};
|
|
1677
|
+
content: {
|
|
1678
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1679
|
+
};
|
|
1680
|
+
};
|
|
1681
|
+
};
|
|
1682
|
+
};
|
|
1683
|
+
openapi: {
|
|
1684
|
+
parameters: {
|
|
1685
|
+
query?: never;
|
|
1686
|
+
header?: never;
|
|
1687
|
+
path?: never;
|
|
1688
|
+
cookie?: never;
|
|
1689
|
+
};
|
|
1690
|
+
requestBody?: never;
|
|
1691
|
+
responses: {
|
|
1692
|
+
/** @description The answer. */
|
|
1693
|
+
200: {
|
|
1694
|
+
headers: {
|
|
1695
|
+
[name: string]: unknown;
|
|
1696
|
+
};
|
|
1697
|
+
content: {
|
|
1698
|
+
"application/json": {
|
|
1699
|
+
[key: string]: unknown;
|
|
1700
|
+
};
|
|
1701
|
+
};
|
|
1702
|
+
};
|
|
1703
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1704
|
+
408: {
|
|
1705
|
+
headers: {
|
|
1706
|
+
[name: string]: unknown;
|
|
1707
|
+
};
|
|
1708
|
+
content: {
|
|
1709
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1710
|
+
};
|
|
1711
|
+
};
|
|
1712
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1713
|
+
503: {
|
|
1714
|
+
headers: {
|
|
1715
|
+
[name: string]: unknown;
|
|
1716
|
+
};
|
|
1717
|
+
content: {
|
|
1718
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1719
|
+
};
|
|
1720
|
+
};
|
|
1721
|
+
};
|
|
1722
|
+
};
|
|
1723
|
+
resetReplay: {
|
|
1724
|
+
parameters: {
|
|
1725
|
+
query?: never;
|
|
1726
|
+
header?: never;
|
|
1727
|
+
path?: never;
|
|
1728
|
+
cookie?: never;
|
|
1729
|
+
};
|
|
1730
|
+
requestBody?: never;
|
|
1731
|
+
responses: {
|
|
1732
|
+
/** @description The answer. */
|
|
1733
|
+
200: {
|
|
1734
|
+
headers: {
|
|
1735
|
+
[name: string]: unknown;
|
|
1736
|
+
};
|
|
1737
|
+
content: {
|
|
1738
|
+
"application/json": components["schemas"]["Replay"];
|
|
1739
|
+
};
|
|
1740
|
+
};
|
|
1741
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1742
|
+
408: {
|
|
1743
|
+
headers: {
|
|
1744
|
+
[name: string]: unknown;
|
|
1745
|
+
};
|
|
1746
|
+
content: {
|
|
1747
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1748
|
+
};
|
|
1749
|
+
};
|
|
1750
|
+
/** @description The node keeps no replay memory because it has run no obfuscated transport, or an earlier reset is not known to be on disk yet. Nothing was changed. */
|
|
1751
|
+
409: {
|
|
1752
|
+
headers: {
|
|
1753
|
+
[name: string]: unknown;
|
|
1754
|
+
};
|
|
1755
|
+
content: {
|
|
1756
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1757
|
+
};
|
|
1758
|
+
};
|
|
1759
|
+
/** @description replay_unwritten: the replay file could not be written, so the reset may or may not be on disk. The node accepts no proof until it has written the floor and the limit it had back, and the reset has to be asked for again. replay_writing: the write has not ended within 10 seconds and the reset is in force when it does, so it must not be asked for again: replay.resets of GET /v1/stats grows by one when it has landed. */
|
|
1760
|
+
500: {
|
|
1761
|
+
headers: {
|
|
1762
|
+
[name: string]: unknown;
|
|
1763
|
+
};
|
|
1764
|
+
content: {
|
|
1765
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1766
|
+
};
|
|
1767
|
+
};
|
|
1768
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1769
|
+
503: {
|
|
1770
|
+
headers: {
|
|
1771
|
+
[name: string]: unknown;
|
|
1772
|
+
};
|
|
1773
|
+
content: {
|
|
1774
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1775
|
+
};
|
|
1776
|
+
};
|
|
1777
|
+
};
|
|
1778
|
+
};
|
|
1779
|
+
listSessions: {
|
|
1780
|
+
parameters: {
|
|
1781
|
+
query?: never;
|
|
1782
|
+
header?: never;
|
|
1783
|
+
path?: never;
|
|
1784
|
+
cookie?: never;
|
|
1785
|
+
};
|
|
1786
|
+
requestBody?: never;
|
|
1787
|
+
responses: {
|
|
1788
|
+
/** @description The answer. */
|
|
1789
|
+
200: {
|
|
1790
|
+
headers: {
|
|
1791
|
+
[name: string]: unknown;
|
|
1792
|
+
};
|
|
1793
|
+
content: {
|
|
1794
|
+
"application/json": components["schemas"]["Sessions"];
|
|
1795
|
+
};
|
|
1796
|
+
};
|
|
1797
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1798
|
+
408: {
|
|
1799
|
+
headers: {
|
|
1800
|
+
[name: string]: unknown;
|
|
1801
|
+
};
|
|
1802
|
+
content: {
|
|
1803
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1804
|
+
};
|
|
1805
|
+
};
|
|
1806
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1807
|
+
503: {
|
|
1808
|
+
headers: {
|
|
1809
|
+
[name: string]: unknown;
|
|
1810
|
+
};
|
|
1811
|
+
content: {
|
|
1812
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1813
|
+
};
|
|
1814
|
+
};
|
|
1815
|
+
};
|
|
1816
|
+
};
|
|
1817
|
+
stats: {
|
|
1818
|
+
parameters: {
|
|
1819
|
+
query?: never;
|
|
1820
|
+
header?: never;
|
|
1821
|
+
path?: never;
|
|
1822
|
+
cookie?: never;
|
|
1823
|
+
};
|
|
1824
|
+
requestBody?: never;
|
|
1825
|
+
responses: {
|
|
1826
|
+
/** @description The answer. */
|
|
1827
|
+
200: {
|
|
1828
|
+
headers: {
|
|
1829
|
+
[name: string]: unknown;
|
|
1830
|
+
};
|
|
1831
|
+
content: {
|
|
1832
|
+
"application/json": components["schemas"]["Stats"];
|
|
1833
|
+
};
|
|
1834
|
+
};
|
|
1835
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1836
|
+
408: {
|
|
1837
|
+
headers: {
|
|
1838
|
+
[name: string]: unknown;
|
|
1839
|
+
};
|
|
1840
|
+
content: {
|
|
1841
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1842
|
+
};
|
|
1843
|
+
};
|
|
1844
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1845
|
+
503: {
|
|
1846
|
+
headers: {
|
|
1847
|
+
[name: string]: unknown;
|
|
1848
|
+
};
|
|
1849
|
+
content: {
|
|
1850
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1851
|
+
};
|
|
1852
|
+
};
|
|
1853
|
+
};
|
|
1854
|
+
};
|
|
1855
|
+
status: {
|
|
1856
|
+
parameters: {
|
|
1857
|
+
query?: never;
|
|
1858
|
+
header?: never;
|
|
1859
|
+
path?: never;
|
|
1860
|
+
cookie?: never;
|
|
1861
|
+
};
|
|
1862
|
+
requestBody?: never;
|
|
1863
|
+
responses: {
|
|
1864
|
+
/** @description The answer. */
|
|
1865
|
+
200: {
|
|
1866
|
+
headers: {
|
|
1867
|
+
[name: string]: unknown;
|
|
1868
|
+
};
|
|
1869
|
+
content: {
|
|
1870
|
+
"application/json": components["schemas"]["Status"];
|
|
1871
|
+
};
|
|
1872
|
+
};
|
|
1873
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1874
|
+
408: {
|
|
1875
|
+
headers: {
|
|
1876
|
+
[name: string]: unknown;
|
|
1877
|
+
};
|
|
1878
|
+
content: {
|
|
1879
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1880
|
+
};
|
|
1881
|
+
};
|
|
1882
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1883
|
+
503: {
|
|
1884
|
+
headers: {
|
|
1885
|
+
[name: string]: unknown;
|
|
1886
|
+
};
|
|
1887
|
+
content: {
|
|
1888
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1889
|
+
};
|
|
1890
|
+
};
|
|
1891
|
+
};
|
|
1892
|
+
};
|
|
1893
|
+
listUsers: {
|
|
1894
|
+
parameters: {
|
|
1895
|
+
query?: never;
|
|
1896
|
+
header?: never;
|
|
1897
|
+
path?: never;
|
|
1898
|
+
cookie?: never;
|
|
1899
|
+
};
|
|
1900
|
+
requestBody?: never;
|
|
1901
|
+
responses: {
|
|
1902
|
+
/** @description The answer. */
|
|
1903
|
+
200: {
|
|
1904
|
+
headers: {
|
|
1905
|
+
[name: string]: unknown;
|
|
1906
|
+
};
|
|
1907
|
+
content: {
|
|
1908
|
+
"application/json": components["schemas"]["Users"];
|
|
1909
|
+
};
|
|
1910
|
+
};
|
|
1911
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1912
|
+
408: {
|
|
1913
|
+
headers: {
|
|
1914
|
+
[name: string]: unknown;
|
|
1915
|
+
};
|
|
1916
|
+
content: {
|
|
1917
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1918
|
+
};
|
|
1919
|
+
};
|
|
1920
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1921
|
+
503: {
|
|
1922
|
+
headers: {
|
|
1923
|
+
[name: string]: unknown;
|
|
1924
|
+
};
|
|
1925
|
+
content: {
|
|
1926
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1927
|
+
};
|
|
1928
|
+
};
|
|
1929
|
+
};
|
|
1930
|
+
};
|
|
1931
|
+
getUser: {
|
|
1932
|
+
parameters: {
|
|
1933
|
+
query?: never;
|
|
1934
|
+
header?: never;
|
|
1935
|
+
path: {
|
|
1936
|
+
name: string;
|
|
1937
|
+
};
|
|
1938
|
+
cookie?: never;
|
|
1939
|
+
};
|
|
1940
|
+
requestBody?: never;
|
|
1941
|
+
responses: {
|
|
1942
|
+
/** @description The answer. */
|
|
1943
|
+
200: {
|
|
1944
|
+
headers: {
|
|
1945
|
+
[name: string]: unknown;
|
|
1946
|
+
};
|
|
1947
|
+
content: {
|
|
1948
|
+
"application/json": components["schemas"]["User"];
|
|
1949
|
+
};
|
|
1950
|
+
};
|
|
1951
|
+
/** @description The running config has no user of that name. */
|
|
1952
|
+
404: {
|
|
1953
|
+
headers: {
|
|
1954
|
+
[name: string]: unknown;
|
|
1955
|
+
};
|
|
1956
|
+
content: {
|
|
1957
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1958
|
+
};
|
|
1959
|
+
};
|
|
1960
|
+
/** @description The request was not finished within 30 seconds. */
|
|
1961
|
+
408: {
|
|
1962
|
+
headers: {
|
|
1963
|
+
[name: string]: unknown;
|
|
1964
|
+
};
|
|
1965
|
+
content: {
|
|
1966
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1967
|
+
};
|
|
1968
|
+
};
|
|
1969
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
1970
|
+
503: {
|
|
1971
|
+
headers: {
|
|
1972
|
+
[name: string]: unknown;
|
|
1973
|
+
};
|
|
1974
|
+
content: {
|
|
1975
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
1976
|
+
};
|
|
1977
|
+
};
|
|
1978
|
+
};
|
|
1979
|
+
};
|
|
1980
|
+
resetUsage: {
|
|
1981
|
+
parameters: {
|
|
1982
|
+
query?: never;
|
|
1983
|
+
header?: never;
|
|
1984
|
+
path: {
|
|
1985
|
+
name: string;
|
|
1986
|
+
};
|
|
1987
|
+
cookie?: never;
|
|
1988
|
+
};
|
|
1989
|
+
requestBody?: {
|
|
1990
|
+
content: {
|
|
1991
|
+
"application/json": components["schemas"]["ResetUsage"];
|
|
1992
|
+
};
|
|
1993
|
+
};
|
|
1994
|
+
responses: {
|
|
1995
|
+
/** @description The answer. */
|
|
1996
|
+
200: {
|
|
1997
|
+
headers: {
|
|
1998
|
+
[name: string]: unknown;
|
|
1999
|
+
};
|
|
2000
|
+
content: {
|
|
2001
|
+
"application/json": components["schemas"]["User"];
|
|
2002
|
+
};
|
|
2003
|
+
};
|
|
2004
|
+
/** @description The body is not one JSON document, or could not be read to its end. */
|
|
2005
|
+
400: {
|
|
2006
|
+
headers: {
|
|
2007
|
+
[name: string]: unknown;
|
|
2008
|
+
};
|
|
2009
|
+
content: {
|
|
2010
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2011
|
+
};
|
|
2012
|
+
};
|
|
2013
|
+
/** @description The running config has no user of that name. Nothing was changed. */
|
|
2014
|
+
404: {
|
|
2015
|
+
headers: {
|
|
2016
|
+
[name: string]: unknown;
|
|
2017
|
+
};
|
|
2018
|
+
content: {
|
|
2019
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2020
|
+
};
|
|
2021
|
+
};
|
|
2022
|
+
/** @description The body was not read within 30 seconds. Nothing was changed: once the node has begun the reset, the answer waits for it and is never this one. */
|
|
2023
|
+
408: {
|
|
2024
|
+
headers: {
|
|
2025
|
+
[name: string]: unknown;
|
|
2026
|
+
};
|
|
2027
|
+
content: {
|
|
2028
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2029
|
+
};
|
|
2030
|
+
};
|
|
2031
|
+
/** @description The body is larger than 4 MiB. */
|
|
2032
|
+
413: {
|
|
2033
|
+
headers: {
|
|
2034
|
+
[name: string]: unknown;
|
|
2035
|
+
};
|
|
2036
|
+
content: {
|
|
2037
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2038
|
+
};
|
|
2039
|
+
};
|
|
2040
|
+
/** @description The body was not sent as application/json. */
|
|
2041
|
+
415: {
|
|
2042
|
+
headers: {
|
|
2043
|
+
[name: string]: unknown;
|
|
2044
|
+
};
|
|
2045
|
+
content: {
|
|
2046
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2047
|
+
};
|
|
2048
|
+
};
|
|
2049
|
+
/** @description The body is JSON and not what a usage reset takes. Nothing was changed. */
|
|
2050
|
+
422: {
|
|
2051
|
+
headers: {
|
|
2052
|
+
[name: string]: unknown;
|
|
2053
|
+
};
|
|
2054
|
+
content: {
|
|
2055
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2056
|
+
};
|
|
2057
|
+
};
|
|
2058
|
+
/** @description The node already serves as many connections, or as many event streams, as it takes at once. */
|
|
2059
|
+
503: {
|
|
2060
|
+
headers: {
|
|
2061
|
+
[name: string]: unknown;
|
|
2062
|
+
};
|
|
2063
|
+
content: {
|
|
2064
|
+
"application/json": components["schemas"]["ErrorBody"];
|
|
2065
|
+
};
|
|
2066
|
+
};
|
|
2067
|
+
};
|
|
2068
|
+
};
|
|
2069
|
+
}
|