@litebackup/sdk 0.0.0-stage → 0.3.18
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/dist/src/backup.d.ts +66 -0
- package/dist/src/backup.js +139 -0
- package/dist/src/case.d.ts +9 -0
- package/dist/src/case.js +14 -0
- package/dist/src/client.d.ts +174 -0
- package/dist/src/client.js +284 -0
- package/dist/src/duration.d.ts +4 -0
- package/dist/src/duration.js +15 -0
- package/dist/src/failover.d.ts +69 -0
- package/dist/src/failover.js +161 -0
- package/dist/src/generated/client.d.ts +1736 -0
- package/dist/src/generated/client.js +5 -0
- package/dist/src/helpers.d.ts +38 -0
- package/dist/src/helpers.js +80 -0
- package/dist/src/index.d.ts +17 -0
- package/dist/src/index.js +8 -0
- package/dist/src/launch.d.ts +27 -0
- package/dist/src/launch.js +98 -0
- package/dist/src/paths.d.ts +15 -0
- package/dist/src/paths.js +42 -0
- package/dist/src/release.d.ts +39 -0
- package/dist/src/release.js +67 -0
- package/dist/src/socket.d.ts +20 -0
- package/dist/src/socket.js +44 -0
- package/dist/src/types.d.ts +41 -0
- package/dist/src/types.js +16 -0
- package/package.json +36 -4
- package/README.md +0 -3
|
@@ -0,0 +1,1736 @@
|
|
|
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/status/show": {
|
|
7
|
+
parameters: {
|
|
8
|
+
query?: never;
|
|
9
|
+
header?: never;
|
|
10
|
+
path?: never;
|
|
11
|
+
cookie?: never;
|
|
12
|
+
};
|
|
13
|
+
/** @description Session, server, and every database on this machine with its role and state. */
|
|
14
|
+
get: operations["showStatus"];
|
|
15
|
+
put?: never;
|
|
16
|
+
post?: never;
|
|
17
|
+
delete?: never;
|
|
18
|
+
options?: never;
|
|
19
|
+
head?: never;
|
|
20
|
+
patch?: never;
|
|
21
|
+
trace?: never;
|
|
22
|
+
};
|
|
23
|
+
"/v1/databases/list": {
|
|
24
|
+
parameters: {
|
|
25
|
+
query?: never;
|
|
26
|
+
header?: never;
|
|
27
|
+
path?: never;
|
|
28
|
+
cookie?: never;
|
|
29
|
+
};
|
|
30
|
+
/** @description Every database on this machine with its role and state. */
|
|
31
|
+
get: operations["listDatabases"];
|
|
32
|
+
put?: never;
|
|
33
|
+
post?: never;
|
|
34
|
+
delete?: never;
|
|
35
|
+
options?: never;
|
|
36
|
+
head?: never;
|
|
37
|
+
patch?: never;
|
|
38
|
+
trace?: never;
|
|
39
|
+
};
|
|
40
|
+
"/v1/databases/status": {
|
|
41
|
+
parameters: {
|
|
42
|
+
query?: never;
|
|
43
|
+
header?: never;
|
|
44
|
+
path?: never;
|
|
45
|
+
cookie?: never;
|
|
46
|
+
};
|
|
47
|
+
/** @description One database: its role, state, and the versions the server and the bucket hold. */
|
|
48
|
+
get: operations["showDatabaseStatus"];
|
|
49
|
+
put?: never;
|
|
50
|
+
post?: never;
|
|
51
|
+
delete?: never;
|
|
52
|
+
options?: never;
|
|
53
|
+
head?: never;
|
|
54
|
+
patch?: never;
|
|
55
|
+
trace?: never;
|
|
56
|
+
};
|
|
57
|
+
"/v1/databases/versions": {
|
|
58
|
+
parameters: {
|
|
59
|
+
query?: never;
|
|
60
|
+
header?: never;
|
|
61
|
+
path?: never;
|
|
62
|
+
cookie?: never;
|
|
63
|
+
};
|
|
64
|
+
/** @description The versions of a database the server can restore, oldest first, from server history and kept bucket objects. */
|
|
65
|
+
get: operations["listVersions"];
|
|
66
|
+
put?: never;
|
|
67
|
+
post?: never;
|
|
68
|
+
delete?: never;
|
|
69
|
+
options?: never;
|
|
70
|
+
head?: never;
|
|
71
|
+
patch?: never;
|
|
72
|
+
trace?: never;
|
|
73
|
+
};
|
|
74
|
+
"/v1/databases/restore": {
|
|
75
|
+
parameters: {
|
|
76
|
+
query?: never;
|
|
77
|
+
header?: never;
|
|
78
|
+
path?: never;
|
|
79
|
+
cookie?: never;
|
|
80
|
+
};
|
|
81
|
+
get?: never;
|
|
82
|
+
put?: never;
|
|
83
|
+
/** @description Write a version of a database to a new file and run quick_check. The path must be absolute, its directory must exist, and an existing file is never overwritten (409 exists). The file belongs to the user the daemon runs as. */
|
|
84
|
+
post: operations["restoreDatabase"];
|
|
85
|
+
delete?: never;
|
|
86
|
+
options?: never;
|
|
87
|
+
head?: never;
|
|
88
|
+
patch?: never;
|
|
89
|
+
trace?: never;
|
|
90
|
+
};
|
|
91
|
+
"/v1/databases/sync": {
|
|
92
|
+
parameters: {
|
|
93
|
+
query?: never;
|
|
94
|
+
header?: never;
|
|
95
|
+
path?: never;
|
|
96
|
+
cookie?: never;
|
|
97
|
+
};
|
|
98
|
+
get?: never;
|
|
99
|
+
put?: never;
|
|
100
|
+
/** @description Sync a database now and wait for the server acknowledgement. */
|
|
101
|
+
post: operations["syncDatabase"];
|
|
102
|
+
delete?: never;
|
|
103
|
+
options?: never;
|
|
104
|
+
head?: never;
|
|
105
|
+
patch?: never;
|
|
106
|
+
trace?: never;
|
|
107
|
+
};
|
|
108
|
+
"/v1/databases/acquire": {
|
|
109
|
+
parameters: {
|
|
110
|
+
query?: never;
|
|
111
|
+
header?: never;
|
|
112
|
+
path?: never;
|
|
113
|
+
cookie?: never;
|
|
114
|
+
};
|
|
115
|
+
get?: never;
|
|
116
|
+
put?: never;
|
|
117
|
+
/** @description Take the write lock on a database and make the local file the server head, for worker pools that move databases between machines. An existing file becomes the first version when the server has none, is adopted when its hashes match the head, and is fast-forwarded when it is a clean but stale copy. Any other existing file is a conflict and is left untouched. A copy this machine wrote that diverged is set aside as <path>.conflict-<time>.sqlite and the head is written in its place. Without a path, the path this machine already uses is taken, which brings an offloaded database back. */
|
|
118
|
+
post: operations["acquireDatabase"];
|
|
119
|
+
delete?: never;
|
|
120
|
+
options?: never;
|
|
121
|
+
head?: never;
|
|
122
|
+
patch?: never;
|
|
123
|
+
trace?: never;
|
|
124
|
+
};
|
|
125
|
+
"/v1/databases/release": {
|
|
126
|
+
parameters: {
|
|
127
|
+
query?: never;
|
|
128
|
+
header?: never;
|
|
129
|
+
path?: never;
|
|
130
|
+
cookie?: never;
|
|
131
|
+
};
|
|
132
|
+
get?: never;
|
|
133
|
+
put?: never;
|
|
134
|
+
/** @description Sync an acquired database a final time, run its maintenance, and release its write lock. */
|
|
135
|
+
post: operations["releaseDatabase"];
|
|
136
|
+
delete?: never;
|
|
137
|
+
options?: never;
|
|
138
|
+
head?: never;
|
|
139
|
+
patch?: never;
|
|
140
|
+
trace?: never;
|
|
141
|
+
};
|
|
142
|
+
"/v1/databases/offload": {
|
|
143
|
+
parameters: {
|
|
144
|
+
query?: never;
|
|
145
|
+
header?: never;
|
|
146
|
+
path?: never;
|
|
147
|
+
cookie?: never;
|
|
148
|
+
};
|
|
149
|
+
get?: never;
|
|
150
|
+
put?: never;
|
|
151
|
+
/** @description Remove the local file of a released database once the server reports its last version is in the bucket. acquire brings it back. */
|
|
152
|
+
post: operations["offloadDatabase"];
|
|
153
|
+
delete?: never;
|
|
154
|
+
options?: never;
|
|
155
|
+
head?: never;
|
|
156
|
+
patch?: never;
|
|
157
|
+
trace?: never;
|
|
158
|
+
};
|
|
159
|
+
"/v1/databases/writer": {
|
|
160
|
+
parameters: {
|
|
161
|
+
query?: never;
|
|
162
|
+
header?: never;
|
|
163
|
+
path?: never;
|
|
164
|
+
cookie?: never;
|
|
165
|
+
};
|
|
166
|
+
/** @description Which machine writes a database, when its lease runs out, and whether it ran out. */
|
|
167
|
+
get: operations["showWriter"];
|
|
168
|
+
put?: never;
|
|
169
|
+
post?: never;
|
|
170
|
+
delete?: never;
|
|
171
|
+
options?: never;
|
|
172
|
+
head?: never;
|
|
173
|
+
patch?: never;
|
|
174
|
+
trace?: never;
|
|
175
|
+
};
|
|
176
|
+
"/v1/backups/start": {
|
|
177
|
+
parameters: {
|
|
178
|
+
query?: never;
|
|
179
|
+
header?: never;
|
|
180
|
+
path?: never;
|
|
181
|
+
cookie?: never;
|
|
182
|
+
};
|
|
183
|
+
get?: never;
|
|
184
|
+
put?: never;
|
|
185
|
+
/** @description Back up a database, or every database matching a glob, and keep syncing it. The name is the file name, lowercased with other characters turned into -, after an optional prefix; name sets it outright. When another machine already writes that name the call fails with 409 name_in_use, and nothing is overwritten. With wait, the call returns once the server or the bucket holds the first version. */
|
|
186
|
+
post: operations["startBackup"];
|
|
187
|
+
delete?: never;
|
|
188
|
+
options?: never;
|
|
189
|
+
head?: never;
|
|
190
|
+
patch?: never;
|
|
191
|
+
trace?: never;
|
|
192
|
+
};
|
|
193
|
+
"/v1/backups/list": {
|
|
194
|
+
parameters: {
|
|
195
|
+
query?: never;
|
|
196
|
+
header?: never;
|
|
197
|
+
path?: never;
|
|
198
|
+
cookie?: never;
|
|
199
|
+
};
|
|
200
|
+
/** @description Every backup and failover on this machine with how many databases each syncs. */
|
|
201
|
+
get: operations["listBackups"];
|
|
202
|
+
put?: never;
|
|
203
|
+
post?: never;
|
|
204
|
+
delete?: never;
|
|
205
|
+
options?: never;
|
|
206
|
+
head?: never;
|
|
207
|
+
patch?: never;
|
|
208
|
+
trace?: never;
|
|
209
|
+
};
|
|
210
|
+
"/v1/backups/stop": {
|
|
211
|
+
parameters: {
|
|
212
|
+
query?: never;
|
|
213
|
+
header?: never;
|
|
214
|
+
path?: never;
|
|
215
|
+
cookie?: never;
|
|
216
|
+
};
|
|
217
|
+
get?: never;
|
|
218
|
+
put?: never;
|
|
219
|
+
/** @description Stop a backup or failover (failovers stop here too), named by its ID, its database name, or its path, and release its write locks. The files stay. */
|
|
220
|
+
post: operations["stopBackup"];
|
|
221
|
+
delete?: never;
|
|
222
|
+
options?: never;
|
|
223
|
+
head?: never;
|
|
224
|
+
patch?: never;
|
|
225
|
+
trace?: never;
|
|
226
|
+
};
|
|
227
|
+
"/v1/failovers/start": {
|
|
228
|
+
parameters: {
|
|
229
|
+
query?: never;
|
|
230
|
+
header?: never;
|
|
231
|
+
path?: never;
|
|
232
|
+
cookie?: never;
|
|
233
|
+
};
|
|
234
|
+
get?: never;
|
|
235
|
+
put?: never;
|
|
236
|
+
/** @description Run a database on several identical machines. The machine that holds the write lock is the origin and backs the file up; the others keep live read-only replicas at the same path. Each replica asks for the lock about once a second, so one of them takes over once the origin's lease runs out. */
|
|
237
|
+
post: operations["startFailover"];
|
|
238
|
+
delete?: never;
|
|
239
|
+
options?: never;
|
|
240
|
+
head?: never;
|
|
241
|
+
patch?: never;
|
|
242
|
+
trace?: never;
|
|
243
|
+
};
|
|
244
|
+
"/v1/replicas/start": {
|
|
245
|
+
parameters: {
|
|
246
|
+
query?: never;
|
|
247
|
+
header?: never;
|
|
248
|
+
path?: never;
|
|
249
|
+
cookie?: never;
|
|
250
|
+
};
|
|
251
|
+
get?: never;
|
|
252
|
+
put?: never;
|
|
253
|
+
/** @description Keep a live read-only replica of a database, or of every database under a prefix, that streams from the server. A single replica returns once its first version is local. */
|
|
254
|
+
post: operations["startReplica"];
|
|
255
|
+
delete?: never;
|
|
256
|
+
options?: never;
|
|
257
|
+
head?: never;
|
|
258
|
+
patch?: never;
|
|
259
|
+
trace?: never;
|
|
260
|
+
};
|
|
261
|
+
"/v1/replicas/list": {
|
|
262
|
+
parameters: {
|
|
263
|
+
query?: never;
|
|
264
|
+
header?: never;
|
|
265
|
+
path?: never;
|
|
266
|
+
cookie?: never;
|
|
267
|
+
};
|
|
268
|
+
/** @description Prefix replicas and every replica with its version. */
|
|
269
|
+
get: operations["listReplicas"];
|
|
270
|
+
put?: never;
|
|
271
|
+
post?: never;
|
|
272
|
+
delete?: never;
|
|
273
|
+
options?: never;
|
|
274
|
+
head?: never;
|
|
275
|
+
patch?: never;
|
|
276
|
+
trace?: never;
|
|
277
|
+
};
|
|
278
|
+
"/v1/replicas/stop": {
|
|
279
|
+
parameters: {
|
|
280
|
+
query?: never;
|
|
281
|
+
header?: never;
|
|
282
|
+
path?: never;
|
|
283
|
+
cookie?: never;
|
|
284
|
+
};
|
|
285
|
+
get?: never;
|
|
286
|
+
put?: never;
|
|
287
|
+
/** @description Stop a replica, or a prefix and its replicas. The files stay, unlocked, at their last version. */
|
|
288
|
+
post: operations["stopReplica"];
|
|
289
|
+
delete?: never;
|
|
290
|
+
options?: never;
|
|
291
|
+
head?: never;
|
|
292
|
+
patch?: never;
|
|
293
|
+
trace?: never;
|
|
294
|
+
};
|
|
295
|
+
"/v1/conflicts/list": {
|
|
296
|
+
parameters: {
|
|
297
|
+
query?: never;
|
|
298
|
+
header?: never;
|
|
299
|
+
path?: never;
|
|
300
|
+
cookie?: never;
|
|
301
|
+
};
|
|
302
|
+
/** @description Local copies set aside because they diverged from the server. */
|
|
303
|
+
get: operations["listConflicts"];
|
|
304
|
+
put?: never;
|
|
305
|
+
post?: never;
|
|
306
|
+
delete?: never;
|
|
307
|
+
options?: never;
|
|
308
|
+
head?: never;
|
|
309
|
+
patch?: never;
|
|
310
|
+
trace?: never;
|
|
311
|
+
};
|
|
312
|
+
"/v1/conflicts/delete": {
|
|
313
|
+
parameters: {
|
|
314
|
+
query?: never;
|
|
315
|
+
header?: never;
|
|
316
|
+
path?: never;
|
|
317
|
+
cookie?: never;
|
|
318
|
+
};
|
|
319
|
+
get?: never;
|
|
320
|
+
put?: never;
|
|
321
|
+
/** @description Delete a set-aside copy and its -wal and -shm files. */
|
|
322
|
+
post: operations["deleteConflict"];
|
|
323
|
+
delete?: never;
|
|
324
|
+
options?: never;
|
|
325
|
+
head?: never;
|
|
326
|
+
patch?: never;
|
|
327
|
+
trace?: never;
|
|
328
|
+
};
|
|
329
|
+
"/v1/events/list": {
|
|
330
|
+
parameters: {
|
|
331
|
+
query?: never;
|
|
332
|
+
header?: never;
|
|
333
|
+
path?: never;
|
|
334
|
+
cookie?: never;
|
|
335
|
+
};
|
|
336
|
+
/** @description Events after an event ID, oldest first. With wait_millis, the call waits up to that long for the first new event. Failovers report role_changed and writes_set_aside here. */
|
|
337
|
+
get: operations["listEvents"];
|
|
338
|
+
put?: never;
|
|
339
|
+
post?: never;
|
|
340
|
+
delete?: never;
|
|
341
|
+
options?: never;
|
|
342
|
+
head?: never;
|
|
343
|
+
patch?: never;
|
|
344
|
+
trace?: never;
|
|
345
|
+
};
|
|
346
|
+
"/v1/session/shutdown": {
|
|
347
|
+
parameters: {
|
|
348
|
+
query?: never;
|
|
349
|
+
header?: never;
|
|
350
|
+
path?: never;
|
|
351
|
+
cookie?: never;
|
|
352
|
+
};
|
|
353
|
+
get?: never;
|
|
354
|
+
put?: never;
|
|
355
|
+
/** @description Final-sync every database, release every write lock, end the session, and stop the daemon. */
|
|
356
|
+
post: operations["shutdownSession"];
|
|
357
|
+
delete?: never;
|
|
358
|
+
options?: never;
|
|
359
|
+
head?: never;
|
|
360
|
+
patch?: never;
|
|
361
|
+
trace?: never;
|
|
362
|
+
};
|
|
363
|
+
}
|
|
364
|
+
export type webhooks = Record<string, never>;
|
|
365
|
+
export interface components {
|
|
366
|
+
schemas: {
|
|
367
|
+
/** @description A version the server acknowledged. Clients decide what durability is enough. */
|
|
368
|
+
SyncedState: {
|
|
369
|
+
/** Format: int64 */
|
|
370
|
+
version: number;
|
|
371
|
+
/** Format: date-time */
|
|
372
|
+
time?: string;
|
|
373
|
+
};
|
|
374
|
+
DatabaseStatus: {
|
|
375
|
+
name: string;
|
|
376
|
+
path: string;
|
|
377
|
+
/**
|
|
378
|
+
* @description origin when this machine writes the database and backs it up; replica for a live read-only copy
|
|
379
|
+
* @enum {string}
|
|
380
|
+
*/
|
|
381
|
+
role: "origin" | "replica";
|
|
382
|
+
/**
|
|
383
|
+
* @description syncing while changes stream; synced once a released database's last version is on the server; waiting while another machine is the origin; offloaded when the local file was removed because the bucket holds it; stopped for a stopped replica; conflicted when another machine wrote while this copy had changes; error with last_error
|
|
384
|
+
* @enum {string}
|
|
385
|
+
*/
|
|
386
|
+
state: "syncing" | "synced" | "waiting" | "offloaded" | "stopped" | "conflicted" | "error";
|
|
387
|
+
/** @description the database is acquired and released by a worker rather than backed up continuously */
|
|
388
|
+
acquired: boolean;
|
|
389
|
+
/** @description the database belongs to a failover and changes role when the origin does */
|
|
390
|
+
failover: boolean;
|
|
391
|
+
local_changed: boolean;
|
|
392
|
+
synced_server: components["schemas"]["SyncedState"];
|
|
393
|
+
synced_cloud: components["schemas"]["SyncedState"];
|
|
394
|
+
journal_mode: string;
|
|
395
|
+
/** Format: int64 */
|
|
396
|
+
page_count: number;
|
|
397
|
+
/** Format: int64 */
|
|
398
|
+
sync_count: number;
|
|
399
|
+
/** Format: int64 */
|
|
400
|
+
hint_misses: number;
|
|
401
|
+
last_full_scan_reason?: string;
|
|
402
|
+
/** @description the machine label of the last writer this machine saw */
|
|
403
|
+
writer?: string;
|
|
404
|
+
last_error?: string;
|
|
405
|
+
/** Format: date-time */
|
|
406
|
+
last_error_time?: string;
|
|
407
|
+
/** @description what other machines see as the writer while this machine writes */
|
|
408
|
+
machine_label?: string;
|
|
409
|
+
maintenance?: boolean;
|
|
410
|
+
/** @enum {string} */
|
|
411
|
+
offload?: "never" | "released";
|
|
412
|
+
};
|
|
413
|
+
Status: {
|
|
414
|
+
session: string;
|
|
415
|
+
server: string;
|
|
416
|
+
client_version: string;
|
|
417
|
+
session_id: string;
|
|
418
|
+
/** Format: date-time */
|
|
419
|
+
lease_expires?: string;
|
|
420
|
+
watch: string;
|
|
421
|
+
databases: components["schemas"]["DatabaseStatus"][];
|
|
422
|
+
};
|
|
423
|
+
Error: {
|
|
424
|
+
/** @description such as name_in_use (another machine backs up that name), exists (a restore target exists), in_use (another machine writes the database), not_found, still_open, invalid_argument, timeout */
|
|
425
|
+
code: string;
|
|
426
|
+
message: string;
|
|
427
|
+
};
|
|
428
|
+
DatabaseStatusList: {
|
|
429
|
+
databases: components["schemas"]["DatabaseStatus"][];
|
|
430
|
+
};
|
|
431
|
+
RestorableVersion: {
|
|
432
|
+
/** Format: int64 */
|
|
433
|
+
version: number;
|
|
434
|
+
state_digest: string;
|
|
435
|
+
/**
|
|
436
|
+
* Format: date-time
|
|
437
|
+
* @description when the version was synced
|
|
438
|
+
*/
|
|
439
|
+
time: string;
|
|
440
|
+
};
|
|
441
|
+
VersionList: {
|
|
442
|
+
versions: components["schemas"]["RestorableVersion"][];
|
|
443
|
+
/**
|
|
444
|
+
* Format: int64
|
|
445
|
+
* @description pass as after to read the next page
|
|
446
|
+
*/
|
|
447
|
+
next?: number;
|
|
448
|
+
};
|
|
449
|
+
RestoreRequest: {
|
|
450
|
+
name: string;
|
|
451
|
+
/** @description absolute path of a new file in an existing directory */
|
|
452
|
+
path: string;
|
|
453
|
+
/**
|
|
454
|
+
* Format: int64
|
|
455
|
+
* @description the version to restore; the head when neither version nor time is set
|
|
456
|
+
*/
|
|
457
|
+
version?: number;
|
|
458
|
+
/**
|
|
459
|
+
* Format: date-time
|
|
460
|
+
* @description restore the newest version at or before this time
|
|
461
|
+
*/
|
|
462
|
+
time?: string;
|
|
463
|
+
};
|
|
464
|
+
RestoreResult: {
|
|
465
|
+
name: string;
|
|
466
|
+
path: string;
|
|
467
|
+
/** Format: int64 */
|
|
468
|
+
version: number;
|
|
469
|
+
/** Format: int64 */
|
|
470
|
+
page_count: number;
|
|
471
|
+
/** Format: int64 */
|
|
472
|
+
page_size: number;
|
|
473
|
+
state_digest: string;
|
|
474
|
+
};
|
|
475
|
+
NameRequest: {
|
|
476
|
+
name: string;
|
|
477
|
+
};
|
|
478
|
+
AcquireRequest: {
|
|
479
|
+
name: string;
|
|
480
|
+
/** @description absolute path of the local file; defaults to the path this machine uses */
|
|
481
|
+
path?: string;
|
|
482
|
+
/** @description checkpoint and, past the freelist threshold, VACUUM on release */
|
|
483
|
+
maintenance?: boolean;
|
|
484
|
+
/**
|
|
485
|
+
* @description released lets Litebackup delete the released copy once the bucket holds it
|
|
486
|
+
* @enum {string}
|
|
487
|
+
*/
|
|
488
|
+
offload?: "never" | "released";
|
|
489
|
+
/** @description what other machines see as the writer */
|
|
490
|
+
machine_label?: string;
|
|
491
|
+
/**
|
|
492
|
+
* @description on a lost write lock, keep the copy as conflicted or block local writes until the lock is back
|
|
493
|
+
* @enum {string}
|
|
494
|
+
*/
|
|
495
|
+
on_lost?: "conflict" | "block";
|
|
496
|
+
/**
|
|
497
|
+
* Format: int64
|
|
498
|
+
* @description bound on downloading the head
|
|
499
|
+
*/
|
|
500
|
+
timeout_millis?: number;
|
|
501
|
+
};
|
|
502
|
+
Conflict: {
|
|
503
|
+
id: string;
|
|
504
|
+
name: string;
|
|
505
|
+
path: string;
|
|
506
|
+
conflict_path: string;
|
|
507
|
+
/** Format: int64 */
|
|
508
|
+
synced_version: number;
|
|
509
|
+
/** Format: int64 */
|
|
510
|
+
server_version: number;
|
|
511
|
+
reason: string;
|
|
512
|
+
/** Format: date-time */
|
|
513
|
+
created: string;
|
|
514
|
+
};
|
|
515
|
+
AcquireResult: {
|
|
516
|
+
database: components["schemas"]["DatabaseStatus"];
|
|
517
|
+
/** @enum {string} */
|
|
518
|
+
outcome: "created" | "adopted" | "resumed" | "downloaded" | "fast_forwarded" | "healed";
|
|
519
|
+
conflict?: components["schemas"]["Conflict"];
|
|
520
|
+
};
|
|
521
|
+
ReleaseRequest: {
|
|
522
|
+
name: string;
|
|
523
|
+
/**
|
|
524
|
+
* @description server returns once the final sync is acknowledged; cloud waits for the bucket too
|
|
525
|
+
* @enum {string}
|
|
526
|
+
*/
|
|
527
|
+
wait?: "server" | "cloud";
|
|
528
|
+
/** @description remove the local file once the bucket holds the released version */
|
|
529
|
+
offload?: boolean;
|
|
530
|
+
/**
|
|
531
|
+
* Format: int64
|
|
532
|
+
* @description how long to wait for the database to close and for the chosen durability
|
|
533
|
+
*/
|
|
534
|
+
timeout_millis?: number;
|
|
535
|
+
};
|
|
536
|
+
ReleaseResult: {
|
|
537
|
+
database: components["schemas"]["DatabaseStatus"];
|
|
538
|
+
checkpointed: boolean;
|
|
539
|
+
vacuumed: boolean;
|
|
540
|
+
offloaded: boolean;
|
|
541
|
+
};
|
|
542
|
+
Writer: {
|
|
543
|
+
name: string;
|
|
544
|
+
/** @description whether some machine holds the write lock and its lease still runs */
|
|
545
|
+
active: boolean;
|
|
546
|
+
/** @description whether this machine's session holds the write lock */
|
|
547
|
+
this_machine: boolean;
|
|
548
|
+
/** @description the machine label of the writer, or empty when nobody holds the lock */
|
|
549
|
+
machine: string;
|
|
550
|
+
/** Format: date-time */
|
|
551
|
+
acquired?: string;
|
|
552
|
+
/**
|
|
553
|
+
* Format: date-time
|
|
554
|
+
* @description on the server's clock
|
|
555
|
+
*/
|
|
556
|
+
lease_expires?: string;
|
|
557
|
+
/**
|
|
558
|
+
* Format: int64
|
|
559
|
+
* @description how long the lease still runs, negative once it ran out
|
|
560
|
+
*/
|
|
561
|
+
lease_remaining_millis?: number;
|
|
562
|
+
/** @description the writer's lease ran out, so another machine may take over */
|
|
563
|
+
lapsed: boolean;
|
|
564
|
+
};
|
|
565
|
+
BackupRequest: {
|
|
566
|
+
/** @description absolute path, or a glob in the last path segment */
|
|
567
|
+
path: string;
|
|
568
|
+
/** @description the database name for a single path; must already be a valid name */
|
|
569
|
+
name?: string;
|
|
570
|
+
/** @description name prefix such as app/ (a trailing / is added when missing); names are the prefix plus the normalized file name */
|
|
571
|
+
prefix?: string;
|
|
572
|
+
/** @enum {string} */
|
|
573
|
+
watch?: "inotify" | "poll";
|
|
574
|
+
/**
|
|
575
|
+
* Format: int64
|
|
576
|
+
* @description when positive, offload the least recently changed idle databases past this count once the bucket holds them
|
|
577
|
+
*/
|
|
578
|
+
maximum_local_databases?: number;
|
|
579
|
+
/**
|
|
580
|
+
* @description return once the server, or the bucket, holds the first version of every matching database
|
|
581
|
+
* @enum {string}
|
|
582
|
+
*/
|
|
583
|
+
wait?: "none" | "server" | "cloud";
|
|
584
|
+
/**
|
|
585
|
+
* Format: int64
|
|
586
|
+
* @description bound on wait
|
|
587
|
+
*/
|
|
588
|
+
timeout_millis?: number;
|
|
589
|
+
};
|
|
590
|
+
Backup: {
|
|
591
|
+
id: string;
|
|
592
|
+
/** @description the path or glob */
|
|
593
|
+
path: string;
|
|
594
|
+
/** @description the name set for a single path, or empty */
|
|
595
|
+
name: string;
|
|
596
|
+
prefix: string;
|
|
597
|
+
watch: string;
|
|
598
|
+
/** Format: int64 */
|
|
599
|
+
maximum_local_databases: number;
|
|
600
|
+
failover: boolean;
|
|
601
|
+
databases: components["schemas"]["DatabaseStatus"][];
|
|
602
|
+
};
|
|
603
|
+
BackupList: {
|
|
604
|
+
backups: components["schemas"]["Backup"][];
|
|
605
|
+
};
|
|
606
|
+
/** @description One of id, name, or path. */
|
|
607
|
+
StopBackupRequest: {
|
|
608
|
+
id?: string;
|
|
609
|
+
/** @description the name of a database the backup syncs */
|
|
610
|
+
name?: string;
|
|
611
|
+
/** @description the path or glob the backup was started with, or a file it syncs */
|
|
612
|
+
path?: string;
|
|
613
|
+
};
|
|
614
|
+
Empty: Record<string, never>;
|
|
615
|
+
FailoverRequest: {
|
|
616
|
+
/** @description absolute path of the database, the same on every machine */
|
|
617
|
+
path: string;
|
|
618
|
+
/** @description the database name; defaults to the normalized file name */
|
|
619
|
+
name?: string;
|
|
620
|
+
/**
|
|
621
|
+
* Format: int64
|
|
622
|
+
* @description bound on the first download of a replica
|
|
623
|
+
*/
|
|
624
|
+
timeout_millis?: number;
|
|
625
|
+
};
|
|
626
|
+
Failover: {
|
|
627
|
+
name: string;
|
|
628
|
+
path: string;
|
|
629
|
+
/** @enum {string} */
|
|
630
|
+
role: "origin" | "replica";
|
|
631
|
+
database: components["schemas"]["DatabaseStatus"];
|
|
632
|
+
writer: components["schemas"]["Writer"];
|
|
633
|
+
};
|
|
634
|
+
/** @description Either name, for one database, or prefix, for every database under it. */
|
|
635
|
+
ReplicaRequest: {
|
|
636
|
+
name?: string;
|
|
637
|
+
/** @description name prefix such as app; replicates every database under it */
|
|
638
|
+
prefix?: string;
|
|
639
|
+
/** @description for name, the replica file, defaulting to the path this machine uses; for prefix, the directory that receives <to>/<name relative to the prefix> */
|
|
640
|
+
to?: string;
|
|
641
|
+
/**
|
|
642
|
+
* @description lock (default) holds the SQLite write lock so app writes get SQLITE_BUSY while readers carry on; detect rebases after a local write; none trusts apps to open with mode=ro
|
|
643
|
+
* @enum {string}
|
|
644
|
+
*/
|
|
645
|
+
write_protection?: "lock" | "detect" | "none";
|
|
646
|
+
/**
|
|
647
|
+
* Format: int64
|
|
648
|
+
* @description bound on downloading the first version of a single replica
|
|
649
|
+
*/
|
|
650
|
+
timeout_millis?: number;
|
|
651
|
+
};
|
|
652
|
+
PrefixReplica: {
|
|
653
|
+
id: string;
|
|
654
|
+
prefix: string;
|
|
655
|
+
to: string;
|
|
656
|
+
write_protection: string;
|
|
657
|
+
/** Format: int64 */
|
|
658
|
+
databases: number;
|
|
659
|
+
};
|
|
660
|
+
/** @description The replica for a name, or the prefix replica for a prefix. */
|
|
661
|
+
ReplicaResult: {
|
|
662
|
+
database?: components["schemas"]["DatabaseStatus"];
|
|
663
|
+
prefix?: components["schemas"]["PrefixReplica"];
|
|
664
|
+
};
|
|
665
|
+
ReplicaList: {
|
|
666
|
+
prefixes: components["schemas"]["PrefixReplica"][];
|
|
667
|
+
replicas: components["schemas"]["DatabaseStatus"][];
|
|
668
|
+
};
|
|
669
|
+
/** @description Either name for one replica, or prefix and to for a prefix. */
|
|
670
|
+
StopReplicaRequest: {
|
|
671
|
+
name?: string;
|
|
672
|
+
prefix?: string;
|
|
673
|
+
to?: string;
|
|
674
|
+
};
|
|
675
|
+
ConflictList: {
|
|
676
|
+
conflicts: components["schemas"]["Conflict"][];
|
|
677
|
+
};
|
|
678
|
+
IDRequest: {
|
|
679
|
+
id: string;
|
|
680
|
+
};
|
|
681
|
+
Event: {
|
|
682
|
+
/** Format: int64 */
|
|
683
|
+
id: number;
|
|
684
|
+
/** Format: date-time */
|
|
685
|
+
time: string;
|
|
686
|
+
name?: string;
|
|
687
|
+
/** @description such as role_changed (message is origin or replica), writes_set_aside (message names the set-aside file), synced, conflict, downloaded */
|
|
688
|
+
type: string;
|
|
689
|
+
message: string;
|
|
690
|
+
/** @description for role_changed, the new role */
|
|
691
|
+
role?: string;
|
|
692
|
+
/** @description for writes_set_aside, the set-aside copy */
|
|
693
|
+
path?: string;
|
|
694
|
+
};
|
|
695
|
+
EventList: {
|
|
696
|
+
events: components["schemas"]["Event"][];
|
|
697
|
+
/**
|
|
698
|
+
* Format: int64
|
|
699
|
+
* @description pass as after to continue
|
|
700
|
+
*/
|
|
701
|
+
next: number;
|
|
702
|
+
};
|
|
703
|
+
ShutdownRequest: {
|
|
704
|
+
/** @enum {string} */
|
|
705
|
+
wait?: "none" | "server" | "cloud";
|
|
706
|
+
/** Format: int64 */
|
|
707
|
+
timeout_millis?: number;
|
|
708
|
+
};
|
|
709
|
+
ShutdownResult: {
|
|
710
|
+
/** Format: int64 */
|
|
711
|
+
released: number;
|
|
712
|
+
failed: string[];
|
|
713
|
+
};
|
|
714
|
+
};
|
|
715
|
+
responses: never;
|
|
716
|
+
parameters: never;
|
|
717
|
+
requestBodies: never;
|
|
718
|
+
headers: never;
|
|
719
|
+
pathItems: never;
|
|
720
|
+
}
|
|
721
|
+
export type $defs = Record<string, never>;
|
|
722
|
+
export interface operations {
|
|
723
|
+
showStatus: {
|
|
724
|
+
parameters: {
|
|
725
|
+
query?: never;
|
|
726
|
+
header?: never;
|
|
727
|
+
path?: never;
|
|
728
|
+
cookie?: never;
|
|
729
|
+
};
|
|
730
|
+
requestBody?: never;
|
|
731
|
+
responses: {
|
|
732
|
+
/** @description success */
|
|
733
|
+
200: {
|
|
734
|
+
headers: {
|
|
735
|
+
[name: string]: unknown;
|
|
736
|
+
};
|
|
737
|
+
content: {
|
|
738
|
+
"application/json": components["schemas"]["Status"];
|
|
739
|
+
};
|
|
740
|
+
};
|
|
741
|
+
/** @description error */
|
|
742
|
+
500: {
|
|
743
|
+
headers: {
|
|
744
|
+
[name: string]: unknown;
|
|
745
|
+
};
|
|
746
|
+
content: {
|
|
747
|
+
"application/json": components["schemas"]["Error"];
|
|
748
|
+
};
|
|
749
|
+
};
|
|
750
|
+
};
|
|
751
|
+
};
|
|
752
|
+
listDatabases: {
|
|
753
|
+
parameters: {
|
|
754
|
+
query?: never;
|
|
755
|
+
header?: never;
|
|
756
|
+
path?: never;
|
|
757
|
+
cookie?: never;
|
|
758
|
+
};
|
|
759
|
+
requestBody?: never;
|
|
760
|
+
responses: {
|
|
761
|
+
/** @description success */
|
|
762
|
+
200: {
|
|
763
|
+
headers: {
|
|
764
|
+
[name: string]: unknown;
|
|
765
|
+
};
|
|
766
|
+
content: {
|
|
767
|
+
"application/json": components["schemas"]["DatabaseStatusList"];
|
|
768
|
+
};
|
|
769
|
+
};
|
|
770
|
+
/** @description error */
|
|
771
|
+
500: {
|
|
772
|
+
headers: {
|
|
773
|
+
[name: string]: unknown;
|
|
774
|
+
};
|
|
775
|
+
content: {
|
|
776
|
+
"application/json": components["schemas"]["Error"];
|
|
777
|
+
};
|
|
778
|
+
};
|
|
779
|
+
};
|
|
780
|
+
};
|
|
781
|
+
showDatabaseStatus: {
|
|
782
|
+
parameters: {
|
|
783
|
+
query: {
|
|
784
|
+
name: string;
|
|
785
|
+
};
|
|
786
|
+
header?: never;
|
|
787
|
+
path?: never;
|
|
788
|
+
cookie?: never;
|
|
789
|
+
};
|
|
790
|
+
requestBody?: never;
|
|
791
|
+
responses: {
|
|
792
|
+
/** @description success */
|
|
793
|
+
200: {
|
|
794
|
+
headers: {
|
|
795
|
+
[name: string]: unknown;
|
|
796
|
+
};
|
|
797
|
+
content: {
|
|
798
|
+
"application/json": components["schemas"]["DatabaseStatus"];
|
|
799
|
+
};
|
|
800
|
+
};
|
|
801
|
+
/** @description error */
|
|
802
|
+
404: {
|
|
803
|
+
headers: {
|
|
804
|
+
[name: string]: unknown;
|
|
805
|
+
};
|
|
806
|
+
content: {
|
|
807
|
+
"application/json": components["schemas"]["Error"];
|
|
808
|
+
};
|
|
809
|
+
};
|
|
810
|
+
};
|
|
811
|
+
};
|
|
812
|
+
listVersions: {
|
|
813
|
+
parameters: {
|
|
814
|
+
query: {
|
|
815
|
+
name: string;
|
|
816
|
+
/** @description last version of the previous page */
|
|
817
|
+
after?: number;
|
|
818
|
+
limit?: number;
|
|
819
|
+
};
|
|
820
|
+
header?: never;
|
|
821
|
+
path?: never;
|
|
822
|
+
cookie?: never;
|
|
823
|
+
};
|
|
824
|
+
requestBody?: never;
|
|
825
|
+
responses: {
|
|
826
|
+
/** @description success */
|
|
827
|
+
200: {
|
|
828
|
+
headers: {
|
|
829
|
+
[name: string]: unknown;
|
|
830
|
+
};
|
|
831
|
+
content: {
|
|
832
|
+
"application/json": components["schemas"]["VersionList"];
|
|
833
|
+
};
|
|
834
|
+
};
|
|
835
|
+
/** @description error */
|
|
836
|
+
400: {
|
|
837
|
+
headers: {
|
|
838
|
+
[name: string]: unknown;
|
|
839
|
+
};
|
|
840
|
+
content: {
|
|
841
|
+
"application/json": components["schemas"]["Error"];
|
|
842
|
+
};
|
|
843
|
+
};
|
|
844
|
+
/** @description error */
|
|
845
|
+
404: {
|
|
846
|
+
headers: {
|
|
847
|
+
[name: string]: unknown;
|
|
848
|
+
};
|
|
849
|
+
content: {
|
|
850
|
+
"application/json": components["schemas"]["Error"];
|
|
851
|
+
};
|
|
852
|
+
};
|
|
853
|
+
/** @description error */
|
|
854
|
+
503: {
|
|
855
|
+
headers: {
|
|
856
|
+
[name: string]: unknown;
|
|
857
|
+
};
|
|
858
|
+
content: {
|
|
859
|
+
"application/json": components["schemas"]["Error"];
|
|
860
|
+
};
|
|
861
|
+
};
|
|
862
|
+
};
|
|
863
|
+
};
|
|
864
|
+
restoreDatabase: {
|
|
865
|
+
parameters: {
|
|
866
|
+
query?: never;
|
|
867
|
+
header?: never;
|
|
868
|
+
path?: never;
|
|
869
|
+
cookie?: never;
|
|
870
|
+
};
|
|
871
|
+
requestBody: {
|
|
872
|
+
content: {
|
|
873
|
+
"application/json": components["schemas"]["RestoreRequest"];
|
|
874
|
+
};
|
|
875
|
+
};
|
|
876
|
+
responses: {
|
|
877
|
+
/** @description success */
|
|
878
|
+
200: {
|
|
879
|
+
headers: {
|
|
880
|
+
[name: string]: unknown;
|
|
881
|
+
};
|
|
882
|
+
content: {
|
|
883
|
+
"application/json": components["schemas"]["RestoreResult"];
|
|
884
|
+
};
|
|
885
|
+
};
|
|
886
|
+
/** @description error */
|
|
887
|
+
400: {
|
|
888
|
+
headers: {
|
|
889
|
+
[name: string]: unknown;
|
|
890
|
+
};
|
|
891
|
+
content: {
|
|
892
|
+
"application/json": components["schemas"]["Error"];
|
|
893
|
+
};
|
|
894
|
+
};
|
|
895
|
+
/** @description error */
|
|
896
|
+
404: {
|
|
897
|
+
headers: {
|
|
898
|
+
[name: string]: unknown;
|
|
899
|
+
};
|
|
900
|
+
content: {
|
|
901
|
+
"application/json": components["schemas"]["Error"];
|
|
902
|
+
};
|
|
903
|
+
};
|
|
904
|
+
/** @description error */
|
|
905
|
+
409: {
|
|
906
|
+
headers: {
|
|
907
|
+
[name: string]: unknown;
|
|
908
|
+
};
|
|
909
|
+
content: {
|
|
910
|
+
"application/json": components["schemas"]["Error"];
|
|
911
|
+
};
|
|
912
|
+
};
|
|
913
|
+
/** @description error */
|
|
914
|
+
503: {
|
|
915
|
+
headers: {
|
|
916
|
+
[name: string]: unknown;
|
|
917
|
+
};
|
|
918
|
+
content: {
|
|
919
|
+
"application/json": components["schemas"]["Error"];
|
|
920
|
+
};
|
|
921
|
+
};
|
|
922
|
+
/** @description error */
|
|
923
|
+
504: {
|
|
924
|
+
headers: {
|
|
925
|
+
[name: string]: unknown;
|
|
926
|
+
};
|
|
927
|
+
content: {
|
|
928
|
+
"application/json": components["schemas"]["Error"];
|
|
929
|
+
};
|
|
930
|
+
};
|
|
931
|
+
};
|
|
932
|
+
};
|
|
933
|
+
syncDatabase: {
|
|
934
|
+
parameters: {
|
|
935
|
+
query?: never;
|
|
936
|
+
header?: never;
|
|
937
|
+
path?: never;
|
|
938
|
+
cookie?: never;
|
|
939
|
+
};
|
|
940
|
+
requestBody: {
|
|
941
|
+
content: {
|
|
942
|
+
"application/json": components["schemas"]["NameRequest"];
|
|
943
|
+
};
|
|
944
|
+
};
|
|
945
|
+
responses: {
|
|
946
|
+
/** @description success */
|
|
947
|
+
200: {
|
|
948
|
+
headers: {
|
|
949
|
+
[name: string]: unknown;
|
|
950
|
+
};
|
|
951
|
+
content: {
|
|
952
|
+
"application/json": components["schemas"]["DatabaseStatus"];
|
|
953
|
+
};
|
|
954
|
+
};
|
|
955
|
+
/** @description error */
|
|
956
|
+
400: {
|
|
957
|
+
headers: {
|
|
958
|
+
[name: string]: unknown;
|
|
959
|
+
};
|
|
960
|
+
content: {
|
|
961
|
+
"application/json": components["schemas"]["Error"];
|
|
962
|
+
};
|
|
963
|
+
};
|
|
964
|
+
/** @description error */
|
|
965
|
+
404: {
|
|
966
|
+
headers: {
|
|
967
|
+
[name: string]: unknown;
|
|
968
|
+
};
|
|
969
|
+
content: {
|
|
970
|
+
"application/json": components["schemas"]["Error"];
|
|
971
|
+
};
|
|
972
|
+
};
|
|
973
|
+
/** @description error */
|
|
974
|
+
409: {
|
|
975
|
+
headers: {
|
|
976
|
+
[name: string]: unknown;
|
|
977
|
+
};
|
|
978
|
+
content: {
|
|
979
|
+
"application/json": components["schemas"]["Error"];
|
|
980
|
+
};
|
|
981
|
+
};
|
|
982
|
+
/** @description error */
|
|
983
|
+
503: {
|
|
984
|
+
headers: {
|
|
985
|
+
[name: string]: unknown;
|
|
986
|
+
};
|
|
987
|
+
content: {
|
|
988
|
+
"application/json": components["schemas"]["Error"];
|
|
989
|
+
};
|
|
990
|
+
};
|
|
991
|
+
};
|
|
992
|
+
};
|
|
993
|
+
acquireDatabase: {
|
|
994
|
+
parameters: {
|
|
995
|
+
query?: never;
|
|
996
|
+
header?: never;
|
|
997
|
+
path?: never;
|
|
998
|
+
cookie?: never;
|
|
999
|
+
};
|
|
1000
|
+
requestBody: {
|
|
1001
|
+
content: {
|
|
1002
|
+
"application/json": components["schemas"]["AcquireRequest"];
|
|
1003
|
+
};
|
|
1004
|
+
};
|
|
1005
|
+
responses: {
|
|
1006
|
+
/** @description success */
|
|
1007
|
+
200: {
|
|
1008
|
+
headers: {
|
|
1009
|
+
[name: string]: unknown;
|
|
1010
|
+
};
|
|
1011
|
+
content: {
|
|
1012
|
+
"application/json": components["schemas"]["AcquireResult"];
|
|
1013
|
+
};
|
|
1014
|
+
};
|
|
1015
|
+
/** @description error */
|
|
1016
|
+
400: {
|
|
1017
|
+
headers: {
|
|
1018
|
+
[name: string]: unknown;
|
|
1019
|
+
};
|
|
1020
|
+
content: {
|
|
1021
|
+
"application/json": components["schemas"]["Error"];
|
|
1022
|
+
};
|
|
1023
|
+
};
|
|
1024
|
+
/** @description error */
|
|
1025
|
+
404: {
|
|
1026
|
+
headers: {
|
|
1027
|
+
[name: string]: unknown;
|
|
1028
|
+
};
|
|
1029
|
+
content: {
|
|
1030
|
+
"application/json": components["schemas"]["Error"];
|
|
1031
|
+
};
|
|
1032
|
+
};
|
|
1033
|
+
/** @description error */
|
|
1034
|
+
409: {
|
|
1035
|
+
headers: {
|
|
1036
|
+
[name: string]: unknown;
|
|
1037
|
+
};
|
|
1038
|
+
content: {
|
|
1039
|
+
"application/json": components["schemas"]["Error"];
|
|
1040
|
+
};
|
|
1041
|
+
};
|
|
1042
|
+
/** @description error */
|
|
1043
|
+
423: {
|
|
1044
|
+
headers: {
|
|
1045
|
+
[name: string]: unknown;
|
|
1046
|
+
};
|
|
1047
|
+
content: {
|
|
1048
|
+
"application/json": components["schemas"]["Error"];
|
|
1049
|
+
};
|
|
1050
|
+
};
|
|
1051
|
+
/** @description error */
|
|
1052
|
+
503: {
|
|
1053
|
+
headers: {
|
|
1054
|
+
[name: string]: unknown;
|
|
1055
|
+
};
|
|
1056
|
+
content: {
|
|
1057
|
+
"application/json": components["schemas"]["Error"];
|
|
1058
|
+
};
|
|
1059
|
+
};
|
|
1060
|
+
/** @description error */
|
|
1061
|
+
504: {
|
|
1062
|
+
headers: {
|
|
1063
|
+
[name: string]: unknown;
|
|
1064
|
+
};
|
|
1065
|
+
content: {
|
|
1066
|
+
"application/json": components["schemas"]["Error"];
|
|
1067
|
+
};
|
|
1068
|
+
};
|
|
1069
|
+
};
|
|
1070
|
+
};
|
|
1071
|
+
releaseDatabase: {
|
|
1072
|
+
parameters: {
|
|
1073
|
+
query?: never;
|
|
1074
|
+
header?: never;
|
|
1075
|
+
path?: never;
|
|
1076
|
+
cookie?: never;
|
|
1077
|
+
};
|
|
1078
|
+
requestBody: {
|
|
1079
|
+
content: {
|
|
1080
|
+
"application/json": components["schemas"]["ReleaseRequest"];
|
|
1081
|
+
};
|
|
1082
|
+
};
|
|
1083
|
+
responses: {
|
|
1084
|
+
/** @description success */
|
|
1085
|
+
200: {
|
|
1086
|
+
headers: {
|
|
1087
|
+
[name: string]: unknown;
|
|
1088
|
+
};
|
|
1089
|
+
content: {
|
|
1090
|
+
"application/json": components["schemas"]["ReleaseResult"];
|
|
1091
|
+
};
|
|
1092
|
+
};
|
|
1093
|
+
/** @description error */
|
|
1094
|
+
400: {
|
|
1095
|
+
headers: {
|
|
1096
|
+
[name: string]: unknown;
|
|
1097
|
+
};
|
|
1098
|
+
content: {
|
|
1099
|
+
"application/json": components["schemas"]["Error"];
|
|
1100
|
+
};
|
|
1101
|
+
};
|
|
1102
|
+
/** @description error */
|
|
1103
|
+
404: {
|
|
1104
|
+
headers: {
|
|
1105
|
+
[name: string]: unknown;
|
|
1106
|
+
};
|
|
1107
|
+
content: {
|
|
1108
|
+
"application/json": components["schemas"]["Error"];
|
|
1109
|
+
};
|
|
1110
|
+
};
|
|
1111
|
+
/** @description error */
|
|
1112
|
+
409: {
|
|
1113
|
+
headers: {
|
|
1114
|
+
[name: string]: unknown;
|
|
1115
|
+
};
|
|
1116
|
+
content: {
|
|
1117
|
+
"application/json": components["schemas"]["Error"];
|
|
1118
|
+
};
|
|
1119
|
+
};
|
|
1120
|
+
/** @description error */
|
|
1121
|
+
503: {
|
|
1122
|
+
headers: {
|
|
1123
|
+
[name: string]: unknown;
|
|
1124
|
+
};
|
|
1125
|
+
content: {
|
|
1126
|
+
"application/json": components["schemas"]["Error"];
|
|
1127
|
+
};
|
|
1128
|
+
};
|
|
1129
|
+
/** @description error */
|
|
1130
|
+
504: {
|
|
1131
|
+
headers: {
|
|
1132
|
+
[name: string]: unknown;
|
|
1133
|
+
};
|
|
1134
|
+
content: {
|
|
1135
|
+
"application/json": components["schemas"]["Error"];
|
|
1136
|
+
};
|
|
1137
|
+
};
|
|
1138
|
+
};
|
|
1139
|
+
};
|
|
1140
|
+
offloadDatabase: {
|
|
1141
|
+
parameters: {
|
|
1142
|
+
query?: never;
|
|
1143
|
+
header?: never;
|
|
1144
|
+
path?: never;
|
|
1145
|
+
cookie?: never;
|
|
1146
|
+
};
|
|
1147
|
+
requestBody: {
|
|
1148
|
+
content: {
|
|
1149
|
+
"application/json": components["schemas"]["NameRequest"];
|
|
1150
|
+
};
|
|
1151
|
+
};
|
|
1152
|
+
responses: {
|
|
1153
|
+
/** @description success */
|
|
1154
|
+
200: {
|
|
1155
|
+
headers: {
|
|
1156
|
+
[name: string]: unknown;
|
|
1157
|
+
};
|
|
1158
|
+
content: {
|
|
1159
|
+
"application/json": components["schemas"]["DatabaseStatus"];
|
|
1160
|
+
};
|
|
1161
|
+
};
|
|
1162
|
+
/** @description error */
|
|
1163
|
+
400: {
|
|
1164
|
+
headers: {
|
|
1165
|
+
[name: string]: unknown;
|
|
1166
|
+
};
|
|
1167
|
+
content: {
|
|
1168
|
+
"application/json": components["schemas"]["Error"];
|
|
1169
|
+
};
|
|
1170
|
+
};
|
|
1171
|
+
/** @description error */
|
|
1172
|
+
404: {
|
|
1173
|
+
headers: {
|
|
1174
|
+
[name: string]: unknown;
|
|
1175
|
+
};
|
|
1176
|
+
content: {
|
|
1177
|
+
"application/json": components["schemas"]["Error"];
|
|
1178
|
+
};
|
|
1179
|
+
};
|
|
1180
|
+
/** @description error */
|
|
1181
|
+
409: {
|
|
1182
|
+
headers: {
|
|
1183
|
+
[name: string]: unknown;
|
|
1184
|
+
};
|
|
1185
|
+
content: {
|
|
1186
|
+
"application/json": components["schemas"]["Error"];
|
|
1187
|
+
};
|
|
1188
|
+
};
|
|
1189
|
+
/** @description error */
|
|
1190
|
+
503: {
|
|
1191
|
+
headers: {
|
|
1192
|
+
[name: string]: unknown;
|
|
1193
|
+
};
|
|
1194
|
+
content: {
|
|
1195
|
+
"application/json": components["schemas"]["Error"];
|
|
1196
|
+
};
|
|
1197
|
+
};
|
|
1198
|
+
};
|
|
1199
|
+
};
|
|
1200
|
+
showWriter: {
|
|
1201
|
+
parameters: {
|
|
1202
|
+
query: {
|
|
1203
|
+
name: string;
|
|
1204
|
+
};
|
|
1205
|
+
header?: never;
|
|
1206
|
+
path?: never;
|
|
1207
|
+
cookie?: never;
|
|
1208
|
+
};
|
|
1209
|
+
requestBody?: never;
|
|
1210
|
+
responses: {
|
|
1211
|
+
/** @description success */
|
|
1212
|
+
200: {
|
|
1213
|
+
headers: {
|
|
1214
|
+
[name: string]: unknown;
|
|
1215
|
+
};
|
|
1216
|
+
content: {
|
|
1217
|
+
"application/json": components["schemas"]["Writer"];
|
|
1218
|
+
};
|
|
1219
|
+
};
|
|
1220
|
+
/** @description error */
|
|
1221
|
+
400: {
|
|
1222
|
+
headers: {
|
|
1223
|
+
[name: string]: unknown;
|
|
1224
|
+
};
|
|
1225
|
+
content: {
|
|
1226
|
+
"application/json": components["schemas"]["Error"];
|
|
1227
|
+
};
|
|
1228
|
+
};
|
|
1229
|
+
/** @description error */
|
|
1230
|
+
404: {
|
|
1231
|
+
headers: {
|
|
1232
|
+
[name: string]: unknown;
|
|
1233
|
+
};
|
|
1234
|
+
content: {
|
|
1235
|
+
"application/json": components["schemas"]["Error"];
|
|
1236
|
+
};
|
|
1237
|
+
};
|
|
1238
|
+
/** @description error */
|
|
1239
|
+
503: {
|
|
1240
|
+
headers: {
|
|
1241
|
+
[name: string]: unknown;
|
|
1242
|
+
};
|
|
1243
|
+
content: {
|
|
1244
|
+
"application/json": components["schemas"]["Error"];
|
|
1245
|
+
};
|
|
1246
|
+
};
|
|
1247
|
+
};
|
|
1248
|
+
};
|
|
1249
|
+
startBackup: {
|
|
1250
|
+
parameters: {
|
|
1251
|
+
query?: never;
|
|
1252
|
+
header?: never;
|
|
1253
|
+
path?: never;
|
|
1254
|
+
cookie?: never;
|
|
1255
|
+
};
|
|
1256
|
+
requestBody: {
|
|
1257
|
+
content: {
|
|
1258
|
+
"application/json": components["schemas"]["BackupRequest"];
|
|
1259
|
+
};
|
|
1260
|
+
};
|
|
1261
|
+
responses: {
|
|
1262
|
+
/** @description success */
|
|
1263
|
+
200: {
|
|
1264
|
+
headers: {
|
|
1265
|
+
[name: string]: unknown;
|
|
1266
|
+
};
|
|
1267
|
+
content: {
|
|
1268
|
+
"application/json": components["schemas"]["Backup"];
|
|
1269
|
+
};
|
|
1270
|
+
};
|
|
1271
|
+
/** @description error */
|
|
1272
|
+
400: {
|
|
1273
|
+
headers: {
|
|
1274
|
+
[name: string]: unknown;
|
|
1275
|
+
};
|
|
1276
|
+
content: {
|
|
1277
|
+
"application/json": components["schemas"]["Error"];
|
|
1278
|
+
};
|
|
1279
|
+
};
|
|
1280
|
+
/** @description error */
|
|
1281
|
+
409: {
|
|
1282
|
+
headers: {
|
|
1283
|
+
[name: string]: unknown;
|
|
1284
|
+
};
|
|
1285
|
+
content: {
|
|
1286
|
+
"application/json": components["schemas"]["Error"];
|
|
1287
|
+
};
|
|
1288
|
+
};
|
|
1289
|
+
/** @description error */
|
|
1290
|
+
503: {
|
|
1291
|
+
headers: {
|
|
1292
|
+
[name: string]: unknown;
|
|
1293
|
+
};
|
|
1294
|
+
content: {
|
|
1295
|
+
"application/json": components["schemas"]["Error"];
|
|
1296
|
+
};
|
|
1297
|
+
};
|
|
1298
|
+
/** @description error */
|
|
1299
|
+
504: {
|
|
1300
|
+
headers: {
|
|
1301
|
+
[name: string]: unknown;
|
|
1302
|
+
};
|
|
1303
|
+
content: {
|
|
1304
|
+
"application/json": components["schemas"]["Error"];
|
|
1305
|
+
};
|
|
1306
|
+
};
|
|
1307
|
+
};
|
|
1308
|
+
};
|
|
1309
|
+
listBackups: {
|
|
1310
|
+
parameters: {
|
|
1311
|
+
query?: never;
|
|
1312
|
+
header?: never;
|
|
1313
|
+
path?: never;
|
|
1314
|
+
cookie?: never;
|
|
1315
|
+
};
|
|
1316
|
+
requestBody?: never;
|
|
1317
|
+
responses: {
|
|
1318
|
+
/** @description success */
|
|
1319
|
+
200: {
|
|
1320
|
+
headers: {
|
|
1321
|
+
[name: string]: unknown;
|
|
1322
|
+
};
|
|
1323
|
+
content: {
|
|
1324
|
+
"application/json": components["schemas"]["BackupList"];
|
|
1325
|
+
};
|
|
1326
|
+
};
|
|
1327
|
+
/** @description error */
|
|
1328
|
+
500: {
|
|
1329
|
+
headers: {
|
|
1330
|
+
[name: string]: unknown;
|
|
1331
|
+
};
|
|
1332
|
+
content: {
|
|
1333
|
+
"application/json": components["schemas"]["Error"];
|
|
1334
|
+
};
|
|
1335
|
+
};
|
|
1336
|
+
};
|
|
1337
|
+
};
|
|
1338
|
+
stopBackup: {
|
|
1339
|
+
parameters: {
|
|
1340
|
+
query?: never;
|
|
1341
|
+
header?: never;
|
|
1342
|
+
path?: never;
|
|
1343
|
+
cookie?: never;
|
|
1344
|
+
};
|
|
1345
|
+
requestBody: {
|
|
1346
|
+
content: {
|
|
1347
|
+
"application/json": components["schemas"]["StopBackupRequest"];
|
|
1348
|
+
};
|
|
1349
|
+
};
|
|
1350
|
+
responses: {
|
|
1351
|
+
/** @description success */
|
|
1352
|
+
200: {
|
|
1353
|
+
headers: {
|
|
1354
|
+
[name: string]: unknown;
|
|
1355
|
+
};
|
|
1356
|
+
content: {
|
|
1357
|
+
"application/json": components["schemas"]["Empty"];
|
|
1358
|
+
};
|
|
1359
|
+
};
|
|
1360
|
+
/** @description error */
|
|
1361
|
+
400: {
|
|
1362
|
+
headers: {
|
|
1363
|
+
[name: string]: unknown;
|
|
1364
|
+
};
|
|
1365
|
+
content: {
|
|
1366
|
+
"application/json": components["schemas"]["Error"];
|
|
1367
|
+
};
|
|
1368
|
+
};
|
|
1369
|
+
/** @description error */
|
|
1370
|
+
404: {
|
|
1371
|
+
headers: {
|
|
1372
|
+
[name: string]: unknown;
|
|
1373
|
+
};
|
|
1374
|
+
content: {
|
|
1375
|
+
"application/json": components["schemas"]["Error"];
|
|
1376
|
+
};
|
|
1377
|
+
};
|
|
1378
|
+
/** @description error */
|
|
1379
|
+
503: {
|
|
1380
|
+
headers: {
|
|
1381
|
+
[name: string]: unknown;
|
|
1382
|
+
};
|
|
1383
|
+
content: {
|
|
1384
|
+
"application/json": components["schemas"]["Error"];
|
|
1385
|
+
};
|
|
1386
|
+
};
|
|
1387
|
+
};
|
|
1388
|
+
};
|
|
1389
|
+
startFailover: {
|
|
1390
|
+
parameters: {
|
|
1391
|
+
query?: never;
|
|
1392
|
+
header?: never;
|
|
1393
|
+
path?: never;
|
|
1394
|
+
cookie?: never;
|
|
1395
|
+
};
|
|
1396
|
+
requestBody: {
|
|
1397
|
+
content: {
|
|
1398
|
+
"application/json": components["schemas"]["FailoverRequest"];
|
|
1399
|
+
};
|
|
1400
|
+
};
|
|
1401
|
+
responses: {
|
|
1402
|
+
/** @description success */
|
|
1403
|
+
200: {
|
|
1404
|
+
headers: {
|
|
1405
|
+
[name: string]: unknown;
|
|
1406
|
+
};
|
|
1407
|
+
content: {
|
|
1408
|
+
"application/json": components["schemas"]["Failover"];
|
|
1409
|
+
};
|
|
1410
|
+
};
|
|
1411
|
+
/** @description error */
|
|
1412
|
+
400: {
|
|
1413
|
+
headers: {
|
|
1414
|
+
[name: string]: unknown;
|
|
1415
|
+
};
|
|
1416
|
+
content: {
|
|
1417
|
+
"application/json": components["schemas"]["Error"];
|
|
1418
|
+
};
|
|
1419
|
+
};
|
|
1420
|
+
/** @description error */
|
|
1421
|
+
409: {
|
|
1422
|
+
headers: {
|
|
1423
|
+
[name: string]: unknown;
|
|
1424
|
+
};
|
|
1425
|
+
content: {
|
|
1426
|
+
"application/json": components["schemas"]["Error"];
|
|
1427
|
+
};
|
|
1428
|
+
};
|
|
1429
|
+
/** @description error */
|
|
1430
|
+
503: {
|
|
1431
|
+
headers: {
|
|
1432
|
+
[name: string]: unknown;
|
|
1433
|
+
};
|
|
1434
|
+
content: {
|
|
1435
|
+
"application/json": components["schemas"]["Error"];
|
|
1436
|
+
};
|
|
1437
|
+
};
|
|
1438
|
+
/** @description error */
|
|
1439
|
+
504: {
|
|
1440
|
+
headers: {
|
|
1441
|
+
[name: string]: unknown;
|
|
1442
|
+
};
|
|
1443
|
+
content: {
|
|
1444
|
+
"application/json": components["schemas"]["Error"];
|
|
1445
|
+
};
|
|
1446
|
+
};
|
|
1447
|
+
};
|
|
1448
|
+
};
|
|
1449
|
+
startReplica: {
|
|
1450
|
+
parameters: {
|
|
1451
|
+
query?: never;
|
|
1452
|
+
header?: never;
|
|
1453
|
+
path?: never;
|
|
1454
|
+
cookie?: never;
|
|
1455
|
+
};
|
|
1456
|
+
requestBody: {
|
|
1457
|
+
content: {
|
|
1458
|
+
"application/json": components["schemas"]["ReplicaRequest"];
|
|
1459
|
+
};
|
|
1460
|
+
};
|
|
1461
|
+
responses: {
|
|
1462
|
+
/** @description success */
|
|
1463
|
+
200: {
|
|
1464
|
+
headers: {
|
|
1465
|
+
[name: string]: unknown;
|
|
1466
|
+
};
|
|
1467
|
+
content: {
|
|
1468
|
+
"application/json": components["schemas"]["ReplicaResult"];
|
|
1469
|
+
};
|
|
1470
|
+
};
|
|
1471
|
+
/** @description error */
|
|
1472
|
+
400: {
|
|
1473
|
+
headers: {
|
|
1474
|
+
[name: string]: unknown;
|
|
1475
|
+
};
|
|
1476
|
+
content: {
|
|
1477
|
+
"application/json": components["schemas"]["Error"];
|
|
1478
|
+
};
|
|
1479
|
+
};
|
|
1480
|
+
/** @description error */
|
|
1481
|
+
404: {
|
|
1482
|
+
headers: {
|
|
1483
|
+
[name: string]: unknown;
|
|
1484
|
+
};
|
|
1485
|
+
content: {
|
|
1486
|
+
"application/json": components["schemas"]["Error"];
|
|
1487
|
+
};
|
|
1488
|
+
};
|
|
1489
|
+
/** @description error */
|
|
1490
|
+
409: {
|
|
1491
|
+
headers: {
|
|
1492
|
+
[name: string]: unknown;
|
|
1493
|
+
};
|
|
1494
|
+
content: {
|
|
1495
|
+
"application/json": components["schemas"]["Error"];
|
|
1496
|
+
};
|
|
1497
|
+
};
|
|
1498
|
+
/** @description error */
|
|
1499
|
+
503: {
|
|
1500
|
+
headers: {
|
|
1501
|
+
[name: string]: unknown;
|
|
1502
|
+
};
|
|
1503
|
+
content: {
|
|
1504
|
+
"application/json": components["schemas"]["Error"];
|
|
1505
|
+
};
|
|
1506
|
+
};
|
|
1507
|
+
/** @description error */
|
|
1508
|
+
504: {
|
|
1509
|
+
headers: {
|
|
1510
|
+
[name: string]: unknown;
|
|
1511
|
+
};
|
|
1512
|
+
content: {
|
|
1513
|
+
"application/json": components["schemas"]["Error"];
|
|
1514
|
+
};
|
|
1515
|
+
};
|
|
1516
|
+
};
|
|
1517
|
+
};
|
|
1518
|
+
listReplicas: {
|
|
1519
|
+
parameters: {
|
|
1520
|
+
query?: never;
|
|
1521
|
+
header?: never;
|
|
1522
|
+
path?: never;
|
|
1523
|
+
cookie?: never;
|
|
1524
|
+
};
|
|
1525
|
+
requestBody?: never;
|
|
1526
|
+
responses: {
|
|
1527
|
+
/** @description success */
|
|
1528
|
+
200: {
|
|
1529
|
+
headers: {
|
|
1530
|
+
[name: string]: unknown;
|
|
1531
|
+
};
|
|
1532
|
+
content: {
|
|
1533
|
+
"application/json": components["schemas"]["ReplicaList"];
|
|
1534
|
+
};
|
|
1535
|
+
};
|
|
1536
|
+
/** @description error */
|
|
1537
|
+
500: {
|
|
1538
|
+
headers: {
|
|
1539
|
+
[name: string]: unknown;
|
|
1540
|
+
};
|
|
1541
|
+
content: {
|
|
1542
|
+
"application/json": components["schemas"]["Error"];
|
|
1543
|
+
};
|
|
1544
|
+
};
|
|
1545
|
+
};
|
|
1546
|
+
};
|
|
1547
|
+
stopReplica: {
|
|
1548
|
+
parameters: {
|
|
1549
|
+
query?: never;
|
|
1550
|
+
header?: never;
|
|
1551
|
+
path?: never;
|
|
1552
|
+
cookie?: never;
|
|
1553
|
+
};
|
|
1554
|
+
requestBody: {
|
|
1555
|
+
content: {
|
|
1556
|
+
"application/json": components["schemas"]["StopReplicaRequest"];
|
|
1557
|
+
};
|
|
1558
|
+
};
|
|
1559
|
+
responses: {
|
|
1560
|
+
/** @description success */
|
|
1561
|
+
200: {
|
|
1562
|
+
headers: {
|
|
1563
|
+
[name: string]: unknown;
|
|
1564
|
+
};
|
|
1565
|
+
content: {
|
|
1566
|
+
"application/json": components["schemas"]["Empty"];
|
|
1567
|
+
};
|
|
1568
|
+
};
|
|
1569
|
+
/** @description error */
|
|
1570
|
+
400: {
|
|
1571
|
+
headers: {
|
|
1572
|
+
[name: string]: unknown;
|
|
1573
|
+
};
|
|
1574
|
+
content: {
|
|
1575
|
+
"application/json": components["schemas"]["Error"];
|
|
1576
|
+
};
|
|
1577
|
+
};
|
|
1578
|
+
/** @description error */
|
|
1579
|
+
404: {
|
|
1580
|
+
headers: {
|
|
1581
|
+
[name: string]: unknown;
|
|
1582
|
+
};
|
|
1583
|
+
content: {
|
|
1584
|
+
"application/json": components["schemas"]["Error"];
|
|
1585
|
+
};
|
|
1586
|
+
};
|
|
1587
|
+
/** @description error */
|
|
1588
|
+
503: {
|
|
1589
|
+
headers: {
|
|
1590
|
+
[name: string]: unknown;
|
|
1591
|
+
};
|
|
1592
|
+
content: {
|
|
1593
|
+
"application/json": components["schemas"]["Error"];
|
|
1594
|
+
};
|
|
1595
|
+
};
|
|
1596
|
+
};
|
|
1597
|
+
};
|
|
1598
|
+
listConflicts: {
|
|
1599
|
+
parameters: {
|
|
1600
|
+
query?: never;
|
|
1601
|
+
header?: never;
|
|
1602
|
+
path?: never;
|
|
1603
|
+
cookie?: never;
|
|
1604
|
+
};
|
|
1605
|
+
requestBody?: never;
|
|
1606
|
+
responses: {
|
|
1607
|
+
/** @description success */
|
|
1608
|
+
200: {
|
|
1609
|
+
headers: {
|
|
1610
|
+
[name: string]: unknown;
|
|
1611
|
+
};
|
|
1612
|
+
content: {
|
|
1613
|
+
"application/json": components["schemas"]["ConflictList"];
|
|
1614
|
+
};
|
|
1615
|
+
};
|
|
1616
|
+
/** @description error */
|
|
1617
|
+
500: {
|
|
1618
|
+
headers: {
|
|
1619
|
+
[name: string]: unknown;
|
|
1620
|
+
};
|
|
1621
|
+
content: {
|
|
1622
|
+
"application/json": components["schemas"]["Error"];
|
|
1623
|
+
};
|
|
1624
|
+
};
|
|
1625
|
+
};
|
|
1626
|
+
};
|
|
1627
|
+
deleteConflict: {
|
|
1628
|
+
parameters: {
|
|
1629
|
+
query?: never;
|
|
1630
|
+
header?: never;
|
|
1631
|
+
path?: never;
|
|
1632
|
+
cookie?: never;
|
|
1633
|
+
};
|
|
1634
|
+
requestBody: {
|
|
1635
|
+
content: {
|
|
1636
|
+
"application/json": components["schemas"]["IDRequest"];
|
|
1637
|
+
};
|
|
1638
|
+
};
|
|
1639
|
+
responses: {
|
|
1640
|
+
/** @description success */
|
|
1641
|
+
200: {
|
|
1642
|
+
headers: {
|
|
1643
|
+
[name: string]: unknown;
|
|
1644
|
+
};
|
|
1645
|
+
content: {
|
|
1646
|
+
"application/json": components["schemas"]["Empty"];
|
|
1647
|
+
};
|
|
1648
|
+
};
|
|
1649
|
+
/** @description error */
|
|
1650
|
+
400: {
|
|
1651
|
+
headers: {
|
|
1652
|
+
[name: string]: unknown;
|
|
1653
|
+
};
|
|
1654
|
+
content: {
|
|
1655
|
+
"application/json": components["schemas"]["Error"];
|
|
1656
|
+
};
|
|
1657
|
+
};
|
|
1658
|
+
/** @description error */
|
|
1659
|
+
404: {
|
|
1660
|
+
headers: {
|
|
1661
|
+
[name: string]: unknown;
|
|
1662
|
+
};
|
|
1663
|
+
content: {
|
|
1664
|
+
"application/json": components["schemas"]["Error"];
|
|
1665
|
+
};
|
|
1666
|
+
};
|
|
1667
|
+
};
|
|
1668
|
+
};
|
|
1669
|
+
listEvents: {
|
|
1670
|
+
parameters: {
|
|
1671
|
+
query?: {
|
|
1672
|
+
/** @description return events with IDs greater than this one; -1 returns no events and, as next, the newest event's ID, to follow events from now on */
|
|
1673
|
+
after?: number;
|
|
1674
|
+
wait_millis?: number;
|
|
1675
|
+
limit?: number;
|
|
1676
|
+
};
|
|
1677
|
+
header?: never;
|
|
1678
|
+
path?: never;
|
|
1679
|
+
cookie?: never;
|
|
1680
|
+
};
|
|
1681
|
+
requestBody?: never;
|
|
1682
|
+
responses: {
|
|
1683
|
+
/** @description success */
|
|
1684
|
+
200: {
|
|
1685
|
+
headers: {
|
|
1686
|
+
[name: string]: unknown;
|
|
1687
|
+
};
|
|
1688
|
+
content: {
|
|
1689
|
+
"application/json": components["schemas"]["EventList"];
|
|
1690
|
+
};
|
|
1691
|
+
};
|
|
1692
|
+
/** @description error */
|
|
1693
|
+
400: {
|
|
1694
|
+
headers: {
|
|
1695
|
+
[name: string]: unknown;
|
|
1696
|
+
};
|
|
1697
|
+
content: {
|
|
1698
|
+
"application/json": components["schemas"]["Error"];
|
|
1699
|
+
};
|
|
1700
|
+
};
|
|
1701
|
+
};
|
|
1702
|
+
};
|
|
1703
|
+
shutdownSession: {
|
|
1704
|
+
parameters: {
|
|
1705
|
+
query?: never;
|
|
1706
|
+
header?: never;
|
|
1707
|
+
path?: never;
|
|
1708
|
+
cookie?: never;
|
|
1709
|
+
};
|
|
1710
|
+
requestBody: {
|
|
1711
|
+
content: {
|
|
1712
|
+
"application/json": components["schemas"]["ShutdownRequest"];
|
|
1713
|
+
};
|
|
1714
|
+
};
|
|
1715
|
+
responses: {
|
|
1716
|
+
/** @description success */
|
|
1717
|
+
200: {
|
|
1718
|
+
headers: {
|
|
1719
|
+
[name: string]: unknown;
|
|
1720
|
+
};
|
|
1721
|
+
content: {
|
|
1722
|
+
"application/json": components["schemas"]["ShutdownResult"];
|
|
1723
|
+
};
|
|
1724
|
+
};
|
|
1725
|
+
/** @description error */
|
|
1726
|
+
400: {
|
|
1727
|
+
headers: {
|
|
1728
|
+
[name: string]: unknown;
|
|
1729
|
+
};
|
|
1730
|
+
content: {
|
|
1731
|
+
"application/json": components["schemas"]["Error"];
|
|
1732
|
+
};
|
|
1733
|
+
};
|
|
1734
|
+
};
|
|
1735
|
+
};
|
|
1736
|
+
}
|