@leaflow/sdk 0.11.0 → 0.12.0
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/compute/v1/schema.d.ts +269 -260
- package/package.json +1 -1
|
@@ -10,16 +10,16 @@ export interface paths {
|
|
|
10
10
|
path?: never;
|
|
11
11
|
cookie?: never;
|
|
12
12
|
};
|
|
13
|
-
/**
|
|
13
|
+
/** List backups */
|
|
14
14
|
get: operations["list-backups"];
|
|
15
15
|
put?: never;
|
|
16
16
|
/**
|
|
17
|
-
*
|
|
18
|
-
* @description
|
|
17
|
+
* Create a backup
|
|
18
|
+
* @description A backup is a complete copy of a disk held in separate storage: **it remains restorable after the source disk is deleted, and can be restored to another availability zone in the same region.** A snapshot offers neither capability, as it resides in the same storage as the source disk and prevents that disk from being deleted while it exists.
|
|
19
19
|
*
|
|
20
|
-
*
|
|
20
|
+
* Disks attached to a running instance, including system disks, can be backed up.
|
|
21
21
|
*
|
|
22
|
-
*
|
|
22
|
+
* The duration depends on the amount of data. The backup is not complete when this endpoint returns; poll the retrieve endpoint.
|
|
23
23
|
*/
|
|
24
24
|
post: operations["create-backup"];
|
|
25
25
|
delete?: never;
|
|
@@ -36,20 +36,20 @@ export interface paths {
|
|
|
36
36
|
cookie?: never;
|
|
37
37
|
};
|
|
38
38
|
/**
|
|
39
|
-
*
|
|
40
|
-
* @description
|
|
39
|
+
* Retrieve a backup
|
|
40
|
+
* @description Queries the current state of the backup, which makes it slower but more accurate than the list endpoint. Use it to poll creation progress.
|
|
41
41
|
*/
|
|
42
42
|
get: operations["get-backup"];
|
|
43
43
|
put?: never;
|
|
44
44
|
post?: never;
|
|
45
45
|
/**
|
|
46
|
-
*
|
|
47
|
-
* @description
|
|
46
|
+
* Delete a backup
|
|
47
|
+
* @description Independent of the source disk: deletion succeeds whether or not that disk still exists.
|
|
48
48
|
*/
|
|
49
49
|
delete: operations["delete-backup"];
|
|
50
50
|
options?: never;
|
|
51
51
|
head?: never;
|
|
52
|
-
/**
|
|
52
|
+
/** Rename a backup */
|
|
53
53
|
patch: operations["rename-backup"];
|
|
54
54
|
trace?: never;
|
|
55
55
|
};
|
|
@@ -63,10 +63,10 @@ export interface paths {
|
|
|
63
63
|
get?: never;
|
|
64
64
|
put?: never;
|
|
65
65
|
/**
|
|
66
|
-
*
|
|
67
|
-
* @description
|
|
66
|
+
* Restore from a backup
|
|
67
|
+
* @description Restores onto a **newly created** disk. The source disk is unaffected and need not still exist.
|
|
68
68
|
*
|
|
69
|
-
*
|
|
69
|
+
* The target disk type may belong to another availability zone of the same region, and its capacity must not be smaller than the backup. The disk cannot be attached until the restore completes; poll the disk retrieve endpoint.
|
|
70
70
|
*/
|
|
71
71
|
post: operations["restore-backup"];
|
|
72
72
|
delete?: never;
|
|
@@ -82,7 +82,7 @@ export interface paths {
|
|
|
82
82
|
path?: never;
|
|
83
83
|
cookie?: never;
|
|
84
84
|
};
|
|
85
|
-
/**
|
|
85
|
+
/** List disk types on sale */
|
|
86
86
|
get: operations["list-disk-types"];
|
|
87
87
|
put?: never;
|
|
88
88
|
post?: never;
|
|
@@ -100,8 +100,8 @@ export interface paths {
|
|
|
100
100
|
cookie?: never;
|
|
101
101
|
};
|
|
102
102
|
/**
|
|
103
|
-
*
|
|
104
|
-
* @description min_ram_mb
|
|
103
|
+
* List images on sale
|
|
104
|
+
* @description An image whose `min_ram_mb` exceeds the memory of the selected instance type cannot boot. Filter the options accordingly.
|
|
105
105
|
*/
|
|
106
106
|
get: operations["list-images"];
|
|
107
107
|
put?: never;
|
|
@@ -119,7 +119,7 @@ export interface paths {
|
|
|
119
119
|
path?: never;
|
|
120
120
|
cookie?: never;
|
|
121
121
|
};
|
|
122
|
-
/**
|
|
122
|
+
/** List instance types on sale */
|
|
123
123
|
get: operations["list-instance-types"];
|
|
124
124
|
put?: never;
|
|
125
125
|
post?: never;
|
|
@@ -136,7 +136,7 @@ export interface paths {
|
|
|
136
136
|
path?: never;
|
|
137
137
|
cookie?: never;
|
|
138
138
|
};
|
|
139
|
-
/**
|
|
139
|
+
/** List available regions */
|
|
140
140
|
get: operations["list-regions"];
|
|
141
141
|
put?: never;
|
|
142
142
|
post?: never;
|
|
@@ -154,8 +154,8 @@ export interface paths {
|
|
|
154
154
|
cookie?: never;
|
|
155
155
|
};
|
|
156
156
|
/**
|
|
157
|
-
*
|
|
158
|
-
* @description
|
|
157
|
+
* List the availability zones of a region
|
|
158
|
+
* @description A disk and an instance must reside in the same availability zone to be attached. Confirm the zone before creating either.
|
|
159
159
|
*/
|
|
160
160
|
get: operations["list-availability-zones"];
|
|
161
161
|
put?: never;
|
|
@@ -174,14 +174,14 @@ export interface paths {
|
|
|
174
174
|
cookie?: never;
|
|
175
175
|
};
|
|
176
176
|
/**
|
|
177
|
-
*
|
|
178
|
-
* @description
|
|
177
|
+
* List disks
|
|
178
|
+
* @description When both `region_code` and `availability_zone` are supplied, only disks attachable to an instance at that location are returned.
|
|
179
179
|
*/
|
|
180
180
|
get: operations["list-disks"];
|
|
181
181
|
put?: never;
|
|
182
182
|
/**
|
|
183
|
-
*
|
|
184
|
-
* @description
|
|
183
|
+
* Create a disk
|
|
184
|
+
* @description The disk is created in the availability zone of the selected disk type, and an instance must reside in the same zone to attach it. Choosing the disk type therefore determines the zone.
|
|
185
185
|
*/
|
|
186
186
|
post: operations["create-disk"];
|
|
187
187
|
delete?: never;
|
|
@@ -198,22 +198,22 @@ export interface paths {
|
|
|
198
198
|
cookie?: never;
|
|
199
199
|
};
|
|
200
200
|
/**
|
|
201
|
-
*
|
|
202
|
-
* @description
|
|
201
|
+
* Retrieve a disk
|
|
202
|
+
* @description Queries the current state of the disk, which makes it slower but more accurate than the list endpoint.
|
|
203
203
|
*/
|
|
204
204
|
get: operations["get-disk"];
|
|
205
205
|
put?: never;
|
|
206
206
|
post?: never;
|
|
207
207
|
/**
|
|
208
|
-
*
|
|
209
|
-
* @description
|
|
208
|
+
* Delete a disk
|
|
209
|
+
* @description Deletion is rejected while the disk is attached, or while snapshots created from it still exist.
|
|
210
210
|
*/
|
|
211
211
|
delete: operations["delete-disk"];
|
|
212
212
|
options?: never;
|
|
213
213
|
head?: never;
|
|
214
214
|
/**
|
|
215
|
-
*
|
|
216
|
-
* @description
|
|
215
|
+
* Rename a disk
|
|
216
|
+
* @description Changes the name only. Use the resize endpoint for capacity; type and availability zone are immutable.
|
|
217
217
|
*/
|
|
218
218
|
patch: operations["rename-disk"];
|
|
219
219
|
trace?: never;
|
|
@@ -228,8 +228,8 @@ export interface paths {
|
|
|
228
228
|
get?: never;
|
|
229
229
|
put?: never;
|
|
230
230
|
/**
|
|
231
|
-
*
|
|
232
|
-
* @description
|
|
231
|
+
* Resize a disk
|
|
232
|
+
* @description Capacity can only be increased; shrinking is not supported. Extend the file system inside the instance once the resize completes.
|
|
233
233
|
*/
|
|
234
234
|
post: operations["resize-disk"];
|
|
235
235
|
delete?: never;
|
|
@@ -248,12 +248,12 @@ export interface paths {
|
|
|
248
248
|
get?: never;
|
|
249
249
|
put?: never;
|
|
250
250
|
/**
|
|
251
|
-
*
|
|
252
|
-
* @description
|
|
251
|
+
* Revert to a snapshot
|
|
252
|
+
* @description Restores the contents of the disk to the moment the snapshot was taken. **All data written after that moment is lost and cannot be recovered.**
|
|
253
253
|
*
|
|
254
|
-
*
|
|
254
|
+
* Three restrictions apply: only the most recent snapshot of the disk can be reverted to; the disk must be detached from its instance first; and a disk resized since the snapshot was taken cannot be reverted. To return to an earlier point in time, or to keep the existing disk, create a new disk from the snapshot instead.
|
|
255
255
|
*
|
|
256
|
-
*
|
|
256
|
+
* The revert is not complete when this endpoint returns; poll the retrieve endpoint.
|
|
257
257
|
*/
|
|
258
258
|
post: operations["revert-disk"];
|
|
259
259
|
delete?: never;
|
|
@@ -269,14 +269,14 @@ export interface paths {
|
|
|
269
269
|
path?: never;
|
|
270
270
|
cookie?: never;
|
|
271
271
|
};
|
|
272
|
-
/**
|
|
272
|
+
/** List floating IPs */
|
|
273
273
|
get: operations["list-floating-ips"];
|
|
274
274
|
put?: never;
|
|
275
275
|
/**
|
|
276
|
-
*
|
|
277
|
-
* @description
|
|
276
|
+
* Allocate a floating IP
|
|
277
|
+
* @description If the private network is not yet connected to the internet, connectivity is established as part of this call.
|
|
278
278
|
*
|
|
279
|
-
* IPv6
|
|
279
|
+
* IPv6 is not requested through this endpoint. IPv6 addresses are assigned to instances by the private network; enable IPv6 on that network instead.
|
|
280
280
|
*/
|
|
281
281
|
post: operations["allocate-floating-ip"];
|
|
282
282
|
delete?: never;
|
|
@@ -292,13 +292,13 @@ export interface paths {
|
|
|
292
292
|
path?: never;
|
|
293
293
|
cookie?: never;
|
|
294
294
|
};
|
|
295
|
-
/**
|
|
295
|
+
/** Retrieve a floating IP */
|
|
296
296
|
get: operations["get-floating-ip"];
|
|
297
297
|
put?: never;
|
|
298
298
|
post?: never;
|
|
299
299
|
/**
|
|
300
|
-
*
|
|
301
|
-
* @description
|
|
300
|
+
* Release a floating IP
|
|
301
|
+
* @description A released address enters a cooldown period before it is allocated again, so that DNS records and allow-lists still pointing at it do not break immediately. **The same address therefore cannot be re-allocated** for some time after release. Proceed with care.
|
|
302
302
|
*/
|
|
303
303
|
delete: operations["release-floating-ip"];
|
|
304
304
|
options?: never;
|
|
@@ -315,8 +315,8 @@ export interface paths {
|
|
|
315
315
|
};
|
|
316
316
|
get?: never;
|
|
317
317
|
/**
|
|
318
|
-
*
|
|
319
|
-
* @description
|
|
318
|
+
* Set the bandwidth limit
|
|
319
|
+
* @description Limits both directions at once. Limiting egress alone does not prevent ingress traffic from saturating the uplink.
|
|
320
320
|
*/
|
|
321
321
|
put: operations["set-floating-ip-bandwidth"];
|
|
322
322
|
post?: never;
|
|
@@ -334,12 +334,12 @@ export interface paths {
|
|
|
334
334
|
cookie?: never;
|
|
335
335
|
};
|
|
336
336
|
get?: never;
|
|
337
|
-
/**
|
|
337
|
+
/** Bind a floating IP to a network interface */
|
|
338
338
|
put: operations["bind-floating-ip"];
|
|
339
339
|
post?: never;
|
|
340
340
|
/**
|
|
341
|
-
*
|
|
342
|
-
* @description
|
|
341
|
+
* Unbind a floating IP
|
|
342
|
+
* @description The address remains held by the project and simply no longer points at any network interface.
|
|
343
343
|
*/
|
|
344
344
|
delete: operations["unbind-floating-ip"];
|
|
345
345
|
options?: never;
|
|
@@ -354,22 +354,22 @@ export interface paths {
|
|
|
354
354
|
path?: never;
|
|
355
355
|
cookie?: never;
|
|
356
356
|
};
|
|
357
|
-
/**
|
|
357
|
+
/** List instances */
|
|
358
358
|
get: operations["list-instances"];
|
|
359
359
|
put?: never;
|
|
360
360
|
/**
|
|
361
|
-
*
|
|
362
|
-
* @description
|
|
361
|
+
* Create instances
|
|
362
|
+
* @description **A password must be set in the request.** The request is rejected otherwise, since the resulting instance would be unreachable. The platform can generate one, in which case it is returned only in this response.
|
|
363
363
|
*
|
|
364
|
-
* `count`
|
|
364
|
+
* `count` creates several instances at once, 20 at most. Names are numbered `-1`, `-2` automatically and all instances share one password. **`instances` in the response is always an array**, including for a single instance.
|
|
365
365
|
*
|
|
366
|
-
*
|
|
366
|
+
* Instances are created one by one in order. If the sequence stops part way through, because of a quota limit for example, **the instances already created are kept** and `failure` states why it stopped. A failure on the first instance is treated as a failure of the whole request and no instance is created.
|
|
367
367
|
*
|
|
368
|
-
*
|
|
368
|
+
* Exactly one image source must be given: `image_id` for a platform image, `private_image_id` for a private image. Supplying both or neither is rejected.
|
|
369
369
|
*
|
|
370
|
-
*
|
|
370
|
+
* Instances are created in the availability zone of the instance type. Disks to be attached later must reside in the same zone.
|
|
371
371
|
*
|
|
372
|
-
*
|
|
372
|
+
* Creation is not complete when this endpoint returns and `status` is `provisioning`. Poll GET to observe the outcome.
|
|
373
373
|
*/
|
|
374
374
|
post: operations["launch-instance"];
|
|
375
375
|
delete?: never;
|
|
@@ -386,24 +386,24 @@ export interface paths {
|
|
|
386
386
|
cookie?: never;
|
|
387
387
|
};
|
|
388
388
|
/**
|
|
389
|
-
*
|
|
390
|
-
* @description
|
|
389
|
+
* Retrieve an instance
|
|
390
|
+
* @description Queries the current state of the instance, which makes it slower but more accurate than the list endpoint. Use it to poll creation progress.
|
|
391
391
|
*/
|
|
392
392
|
get: operations["get-instance"];
|
|
393
393
|
put?: never;
|
|
394
394
|
post?: never;
|
|
395
395
|
/**
|
|
396
|
-
*
|
|
397
|
-
* @description
|
|
396
|
+
* Release an instance
|
|
397
|
+
* @description The system disk is deleted with the instance, and **snapshots created from the system disk are deleted with it**. Data disks are detached and kept, and their snapshots and backups are unaffected. The primary network interface is released with the instance.
|
|
398
398
|
*
|
|
399
|
-
*
|
|
399
|
+
* An instance being captured as a private image cannot be released. Wait for the capture to finish, or delete that image first.
|
|
400
400
|
*/
|
|
401
401
|
delete: operations["delete-instance"];
|
|
402
402
|
options?: never;
|
|
403
403
|
head?: never;
|
|
404
404
|
/**
|
|
405
|
-
*
|
|
406
|
-
* @description
|
|
405
|
+
* Rename an instance
|
|
406
|
+
* @description Changes the display name only. The hostname inside the instance is unchanged; it equals the instance id.
|
|
407
407
|
*/
|
|
408
408
|
patch: operations["rename-instance"];
|
|
409
409
|
trace?: never;
|
|
@@ -418,12 +418,14 @@ export interface paths {
|
|
|
418
418
|
get?: never;
|
|
419
419
|
put?: never;
|
|
420
420
|
/**
|
|
421
|
-
*
|
|
422
|
-
* @description
|
|
421
|
+
* Start, stop or reboot an instance
|
|
422
|
+
* @description Reboot defaults to a soft reboot, in which the operating system shuts down normally before starting again.
|
|
423
423
|
*
|
|
424
|
-
*
|
|
424
|
+
* A soft reboot has no effect once the system is unresponsive. Set `force` to reboot forcibly: a forced reboot does not wait for the operating system to shut down, so **unwritten data is lost**. `force` applies to `reboot` only.
|
|
425
425
|
*
|
|
426
|
-
*
|
|
426
|
+
* An instance suspended by the platform must be unsuspended first.
|
|
427
|
+
*
|
|
428
|
+
* This endpoint returns immediately and the `status` it returns is a transient state: `starting` for start, `stopping` for stop, `rebooting` for reboot. Poll the instance until it settles at `running` or `stopped`.
|
|
427
429
|
*/
|
|
428
430
|
post: operations["act-on-instance"];
|
|
429
431
|
delete?: never;
|
|
@@ -442,10 +444,10 @@ export interface paths {
|
|
|
442
444
|
get?: never;
|
|
443
445
|
put?: never;
|
|
444
446
|
/**
|
|
445
|
-
*
|
|
446
|
-
* @description
|
|
447
|
+
* Open a remote console
|
|
448
|
+
* @description Operates the instance directly from a browser and does not require the instance to be reachable over the network, which makes it usable when a network misconfiguration prevents login.
|
|
447
449
|
*
|
|
448
|
-
*
|
|
450
|
+
* The returned address is single-use and expires within minutes. **Do not cache it**; request a new one before each use.
|
|
449
451
|
*/
|
|
450
452
|
post: operations["open-instance-console"];
|
|
451
453
|
delete?: never;
|
|
@@ -462,10 +464,10 @@ export interface paths {
|
|
|
462
464
|
cookie?: never;
|
|
463
465
|
};
|
|
464
466
|
/**
|
|
465
|
-
*
|
|
466
|
-
* @description
|
|
467
|
+
* Read the console output
|
|
468
|
+
* @description The raw text produced by the instance during boot and by the kernel. Consult it first when login fails or the remote console shows no output: it reveals where boot stopped, whether the system disk was mounted, and whether initialisation reported errors.
|
|
467
469
|
*
|
|
468
|
-
*
|
|
470
|
+
* Instances in an error state, and instances suspended by the platform, can be read as well.
|
|
469
471
|
*/
|
|
470
472
|
get: operations["get-instance-console-output"];
|
|
471
473
|
put?: never;
|
|
@@ -486,12 +488,12 @@ export interface paths {
|
|
|
486
488
|
get?: never;
|
|
487
489
|
put?: never;
|
|
488
490
|
/**
|
|
489
|
-
*
|
|
490
|
-
* @description
|
|
491
|
+
* Reset the login password
|
|
492
|
+
* @description Changes the root password without a reboot. The instance must be running.
|
|
491
493
|
*
|
|
492
|
-
*
|
|
494
|
+
* **Not every image supports this.** Images whose `supports_password_reset` is false cannot, and a new password can then only be set by rebuilding the instance, which erases all data on the system disk.
|
|
493
495
|
*
|
|
494
|
-
*
|
|
496
|
+
* The request is also rejected when the image is marked as supported but the corresponding component has been removed or stopped inside the instance.
|
|
495
497
|
*/
|
|
496
498
|
post: operations["reset-instance-password"];
|
|
497
499
|
delete?: never;
|
|
@@ -510,8 +512,8 @@ export interface paths {
|
|
|
510
512
|
get?: never;
|
|
511
513
|
put?: never;
|
|
512
514
|
/**
|
|
513
|
-
*
|
|
514
|
-
* @description
|
|
515
|
+
* Rebuild an instance
|
|
516
|
+
* @description **All data on the system disk is erased and cannot be recovered.** Attached data disks are unaffected.
|
|
515
517
|
*/
|
|
516
518
|
post: operations["rebuild-instance"];
|
|
517
519
|
delete?: never;
|
|
@@ -530,12 +532,12 @@ export interface paths {
|
|
|
530
532
|
get?: never;
|
|
531
533
|
put?: never;
|
|
532
534
|
/**
|
|
533
|
-
*
|
|
534
|
-
* @description
|
|
535
|
+
* Resize an instance
|
|
536
|
+
* @description Only an instance type in the same region and availability zone can be selected, as attached disks cannot follow the instance elsewhere.
|
|
535
537
|
*
|
|
536
|
-
*
|
|
538
|
+
* A resize has two steps. This endpoint restarts the instance on the new size and the status becomes `resize_verifying`, at which point the confirm or revert endpoint **must** be called. Until confirmation the target type is recorded in `pending_instance_type_id`, while `instance_type_id` remains the type in effect and billed.
|
|
537
539
|
*
|
|
538
|
-
*
|
|
540
|
+
* **Both sizes hold resources while the resize is unconfirmed.** Confirm promptly once the status becomes `resize_verifying`.
|
|
539
541
|
*/
|
|
540
542
|
post: operations["resize-instance"];
|
|
541
543
|
delete?: never;
|
|
@@ -554,8 +556,8 @@ export interface paths {
|
|
|
554
556
|
get?: never;
|
|
555
557
|
put?: never;
|
|
556
558
|
/**
|
|
557
|
-
*
|
|
558
|
-
* @description
|
|
559
|
+
* Confirm a resize
|
|
560
|
+
* @description Releases the resources held by the previous size. `pending_instance_type_id` becomes the type in effect and is billed from then on.
|
|
559
561
|
*/
|
|
560
562
|
post: operations["confirm-instance-resize"];
|
|
561
563
|
delete?: never;
|
|
@@ -574,8 +576,8 @@ export interface paths {
|
|
|
574
576
|
get?: never;
|
|
575
577
|
put?: never;
|
|
576
578
|
/**
|
|
577
|
-
*
|
|
578
|
-
* @description
|
|
579
|
+
* Revert a resize
|
|
580
|
+
* @description The instance returns to its previous size, `pending_instance_type_id` is discarded, and billing is unaffected by the resize.
|
|
579
581
|
*/
|
|
580
582
|
post: operations["revert-instance-resize"];
|
|
581
583
|
delete?: never;
|
|
@@ -591,12 +593,12 @@ export interface paths {
|
|
|
591
593
|
path?: never;
|
|
592
594
|
cookie?: never;
|
|
593
595
|
};
|
|
594
|
-
/**
|
|
596
|
+
/** List the disks attached to an instance */
|
|
595
597
|
get: operations["list-instance-disks"];
|
|
596
598
|
put?: never;
|
|
597
599
|
/**
|
|
598
|
-
*
|
|
599
|
-
* @description
|
|
600
|
+
* Attach a disk
|
|
601
|
+
* @description The disk must be in the same region and availability zone as the instance. Partition it and mount the file system inside the instance once it is attached.
|
|
600
602
|
*/
|
|
601
603
|
post: operations["attach-disk"];
|
|
602
604
|
delete?: never;
|
|
@@ -616,8 +618,8 @@ export interface paths {
|
|
|
616
618
|
put?: never;
|
|
617
619
|
post?: never;
|
|
618
620
|
/**
|
|
619
|
-
*
|
|
620
|
-
* @description
|
|
621
|
+
* Detach a disk
|
|
622
|
+
* @description Unmount the device inside the instance before calling this endpoint. Forcibly detaching a file system that is being written to corrupts data.
|
|
621
623
|
*/
|
|
622
624
|
delete: operations["detach-disk"];
|
|
623
625
|
options?: never;
|
|
@@ -635,8 +637,8 @@ export interface paths {
|
|
|
635
637
|
get?: never;
|
|
636
638
|
put?: never;
|
|
637
639
|
/**
|
|
638
|
-
*
|
|
639
|
-
* @description
|
|
640
|
+
* Bind a floating IP to an instance
|
|
641
|
+
* @description The floating IP is bound to the primary network interface of the instance.
|
|
640
642
|
*/
|
|
641
643
|
post: operations["attach-instance-floating-ip"];
|
|
642
644
|
delete?: never;
|
|
@@ -655,7 +657,7 @@ export interface paths {
|
|
|
655
657
|
get?: never;
|
|
656
658
|
put?: never;
|
|
657
659
|
post?: never;
|
|
658
|
-
/**
|
|
660
|
+
/** Unbind the floating IP of an instance */
|
|
659
661
|
delete: operations["detach-instance-floating-ip"];
|
|
660
662
|
options?: never;
|
|
661
663
|
head?: never;
|
|
@@ -669,10 +671,10 @@ export interface paths {
|
|
|
669
671
|
path?: never;
|
|
670
672
|
cookie?: never;
|
|
671
673
|
};
|
|
672
|
-
/**
|
|
674
|
+
/** List the network interfaces of an instance */
|
|
673
675
|
get: operations["list-instance-ports"];
|
|
674
676
|
put?: never;
|
|
675
|
-
/**
|
|
677
|
+
/** Attach a network interface */
|
|
676
678
|
post: operations["attach-port"];
|
|
677
679
|
delete?: never;
|
|
678
680
|
options?: never;
|
|
@@ -691,8 +693,8 @@ export interface paths {
|
|
|
691
693
|
put?: never;
|
|
692
694
|
post?: never;
|
|
693
695
|
/**
|
|
694
|
-
*
|
|
695
|
-
* @description
|
|
696
|
+
* Detach a network interface
|
|
697
|
+
* @description The primary network interface cannot be detached; the instance would lose its network address.
|
|
696
698
|
*/
|
|
697
699
|
delete: operations["detach-port"];
|
|
698
700
|
options?: never;
|
|
@@ -708,12 +710,12 @@ export interface paths {
|
|
|
708
710
|
cookie?: never;
|
|
709
711
|
};
|
|
710
712
|
/**
|
|
711
|
-
*
|
|
712
|
-
* @description
|
|
713
|
+
* List the operation log of the project
|
|
714
|
+
* @description Records every write operation in the project: who performed it, when, on what, and whether it succeeded. Read operations are not recorded.
|
|
713
715
|
*
|
|
714
|
-
*
|
|
716
|
+
* **Operations performed by the platform are included, but the individual operator is not disclosed** and `by_platform` is true. Suspension for non-payment and bans for abuse are examples: the time at which an instance was stopped by the platform is needed, whereas the operator is internal information.
|
|
715
717
|
*
|
|
716
|
-
*
|
|
718
|
+
* Fields such as passwords are replaced with a placeholder as the record is written and never appear in `payload`.
|
|
717
719
|
*/
|
|
718
720
|
get: operations["list-operation-logs"];
|
|
719
721
|
put?: never;
|
|
@@ -731,12 +733,12 @@ export interface paths {
|
|
|
731
733
|
path?: never;
|
|
732
734
|
cookie?: never;
|
|
733
735
|
};
|
|
734
|
-
/**
|
|
736
|
+
/** List network interfaces */
|
|
735
737
|
get: operations["list-ports"];
|
|
736
738
|
put?: never;
|
|
737
739
|
/**
|
|
738
|
-
*
|
|
739
|
-
* @description
|
|
740
|
+
* Create a network interface
|
|
741
|
+
* @description The new network interface is not attached to any instance. Primary network interfaces are not created here; they are created with the instance.
|
|
740
742
|
*/
|
|
741
743
|
post: operations["create-port"];
|
|
742
744
|
delete?: never;
|
|
@@ -756,8 +758,8 @@ export interface paths {
|
|
|
756
758
|
put?: never;
|
|
757
759
|
post?: never;
|
|
758
760
|
/**
|
|
759
|
-
*
|
|
760
|
-
* @description
|
|
761
|
+
* Delete a network interface
|
|
762
|
+
* @description The primary network interface cannot be deleted on its own, as it is released with the instance. A network interface still attached to an instance cannot be deleted either.
|
|
761
763
|
*/
|
|
762
764
|
delete: operations["delete-port"];
|
|
763
765
|
options?: never;
|
|
@@ -772,23 +774,23 @@ export interface paths {
|
|
|
772
774
|
path?: never;
|
|
773
775
|
cookie?: never;
|
|
774
776
|
};
|
|
775
|
-
/**
|
|
777
|
+
/** List private images */
|
|
776
778
|
get: operations["list-private-images"];
|
|
777
779
|
put?: never;
|
|
778
780
|
/**
|
|
779
|
-
*
|
|
780
|
-
* @description
|
|
781
|
+
* Capture an instance as a private image
|
|
782
|
+
* @description Captured from the system disk of the instance; data disks are not included. The resulting image can create instances and rebuild them, and remains usable after the source instance is released.
|
|
781
783
|
*
|
|
782
|
-
*
|
|
784
|
+
* **The image reflects the moment the capture started. Later changes to the instance are not included.**
|
|
783
785
|
*
|
|
784
|
-
*
|
|
786
|
+
* The capture has two phases. Poll the retrieve endpoint:
|
|
785
787
|
*
|
|
786
|
-
* - `provisioning`
|
|
787
|
-
* - `uploading`
|
|
788
|
+
* - `provisioning` — the system disk is being read, usually for tens of seconds. The instance remains usable during this phase, although stopping it first is recommended for consistency.
|
|
789
|
+
* - `uploading` — no longer tied to the system disk. **The instance may be started at this point; there is no need to wait for the capture to finish.** The duration of this phase is proportional to the size of the system disk, roughly 3 minutes for 20 GB.
|
|
788
790
|
*
|
|
789
|
-
*
|
|
791
|
+
* The file system of a running instance may be captured mid-write, in which case the image is equivalent to the disk contents after a power loss. Where consistency matters, stop the instance before starting the capture and start it again once the status becomes `uploading`.
|
|
790
792
|
*
|
|
791
|
-
*
|
|
793
|
+
* The instance can be started, stopped and used normally during the capture, but cannot be released.
|
|
792
794
|
*/
|
|
793
795
|
post: operations["create-private-image"];
|
|
794
796
|
delete?: never;
|
|
@@ -805,22 +807,22 @@ export interface paths {
|
|
|
805
807
|
cookie?: never;
|
|
806
808
|
};
|
|
807
809
|
/**
|
|
808
|
-
*
|
|
809
|
-
* @description
|
|
810
|
+
* Retrieve a private image
|
|
811
|
+
* @description Use this endpoint to poll capture progress. When `status` is `error`, `failure` states the reason.
|
|
810
812
|
*/
|
|
811
813
|
get: operations["get-private-image"];
|
|
812
814
|
put?: never;
|
|
813
815
|
post?: never;
|
|
814
816
|
/**
|
|
815
|
-
*
|
|
816
|
-
* @description
|
|
817
|
+
* Delete a private image
|
|
818
|
+
* @description Deletion is rejected while instances created from the image still exist, as they need it in order to be rebuilt.
|
|
817
819
|
*
|
|
818
|
-
*
|
|
820
|
+
* An image whose capture has not finished can be deleted; the capture is aborted.
|
|
819
821
|
*/
|
|
820
822
|
delete: operations["delete-private-image"];
|
|
821
823
|
options?: never;
|
|
822
824
|
head?: never;
|
|
823
|
-
/**
|
|
825
|
+
/** Rename a private image */
|
|
824
826
|
patch: operations["rename-private-image"];
|
|
825
827
|
trace?: never;
|
|
826
828
|
};
|
|
@@ -831,12 +833,12 @@ export interface paths {
|
|
|
831
833
|
path?: never;
|
|
832
834
|
cookie?: never;
|
|
833
835
|
};
|
|
834
|
-
/**
|
|
836
|
+
/** List private networks */
|
|
835
837
|
get: operations["list-private-networks"];
|
|
836
838
|
put?: never;
|
|
837
839
|
/**
|
|
838
|
-
*
|
|
839
|
-
* @description
|
|
840
|
+
* Create a private network
|
|
841
|
+
* @description Creates a network, a router and a default security group in one call. The default security group denies all inbound traffic and permits all outbound traffic.
|
|
840
842
|
*/
|
|
841
843
|
post: operations["create-private-network"];
|
|
842
844
|
delete?: never;
|
|
@@ -852,20 +854,20 @@ export interface paths {
|
|
|
852
854
|
path?: never;
|
|
853
855
|
cookie?: never;
|
|
854
856
|
};
|
|
855
|
-
/**
|
|
857
|
+
/** Retrieve a private network */
|
|
856
858
|
get: operations["get-private-network"];
|
|
857
859
|
put?: never;
|
|
858
860
|
post?: never;
|
|
859
861
|
/**
|
|
860
|
-
*
|
|
861
|
-
* @description
|
|
862
|
+
* Release a private network
|
|
863
|
+
* @description Release is rejected while instances or network interfaces remain in the network. IPv6, the router and the security groups are released with it.
|
|
862
864
|
*/
|
|
863
865
|
delete: operations["delete-private-network"];
|
|
864
866
|
options?: never;
|
|
865
867
|
head?: never;
|
|
866
868
|
/**
|
|
867
|
-
*
|
|
868
|
-
* @description
|
|
869
|
+
* Rename a private network
|
|
870
|
+
* @description Changes the display name only. The CIDR, the routes and the internet gateway are immutable.
|
|
869
871
|
*/
|
|
870
872
|
patch: operations["rename-private-network"];
|
|
871
873
|
trace?: never;
|
|
@@ -877,19 +879,19 @@ export interface paths {
|
|
|
877
879
|
path?: never;
|
|
878
880
|
cookie?: never;
|
|
879
881
|
};
|
|
880
|
-
/**
|
|
882
|
+
/** Retrieve the IPv6 configuration of a private network */
|
|
881
883
|
get: operations["get-private-network-ipv6"];
|
|
882
884
|
put?: never;
|
|
883
885
|
/**
|
|
884
|
-
*
|
|
885
|
-
* @description
|
|
886
|
+
* Enable IPv6 on a private network
|
|
887
|
+
* @description Allocates an IPv6 prefix to the private network. Addresses are assigned to instances by the network itself, can be neither requested nor released individually, and consume no public IPv4 address.
|
|
886
888
|
*
|
|
887
|
-
*
|
|
889
|
+
* If the private network is not yet connected to the internet, connectivity is established as part of this call.
|
|
888
890
|
*/
|
|
889
891
|
post: operations["enable-private-network-ipv6"];
|
|
890
892
|
/**
|
|
891
|
-
*
|
|
892
|
-
* @description
|
|
893
|
+
* Disable IPv6 on a private network
|
|
894
|
+
* @description A released prefix is not re-allocated immediately.
|
|
893
895
|
*/
|
|
894
896
|
delete: operations["disable-private-network-ipv6"];
|
|
895
897
|
options?: never;
|
|
@@ -904,12 +906,12 @@ export interface paths {
|
|
|
904
906
|
path?: never;
|
|
905
907
|
cookie?: never;
|
|
906
908
|
};
|
|
907
|
-
/**
|
|
909
|
+
/** List static routes */
|
|
908
910
|
get: operations["list-routes"];
|
|
909
911
|
put?: never;
|
|
910
912
|
/**
|
|
911
|
-
*
|
|
912
|
-
* @description
|
|
913
|
+
* Create a static route
|
|
914
|
+
* @description Three forms that would sever connectivity are rejected: a destination of `0.0.0.0/0`, which overrides the default route and takes every floating IP offline immediately; a destination equal to the CIDR of a subnet, which overrides its directly connected route; and a next hop equal to the gateway of a subnet, which points back at the router itself.
|
|
913
915
|
*/
|
|
914
916
|
post: operations["create-route"];
|
|
915
917
|
delete?: never;
|
|
@@ -928,7 +930,7 @@ export interface paths {
|
|
|
928
930
|
get?: never;
|
|
929
931
|
put?: never;
|
|
930
932
|
post?: never;
|
|
931
|
-
/**
|
|
933
|
+
/** Delete a static route */
|
|
932
934
|
delete: operations["delete-route"];
|
|
933
935
|
options?: never;
|
|
934
936
|
head?: never;
|
|
@@ -943,12 +945,12 @@ export interface paths {
|
|
|
943
945
|
cookie?: never;
|
|
944
946
|
};
|
|
945
947
|
/**
|
|
946
|
-
*
|
|
947
|
-
* @description IPv6
|
|
948
|
+
* List subnets
|
|
949
|
+
* @description IPv6 subnets are included, with `ip_version` 6. They are created when IPv6 is enabled and cannot be deleted individually.
|
|
948
950
|
*/
|
|
949
951
|
get: operations["list-subnets"];
|
|
950
952
|
put?: never;
|
|
951
|
-
/**
|
|
953
|
+
/** Create a subnet */
|
|
952
954
|
post: operations["create-subnet"];
|
|
953
955
|
delete?: never;
|
|
954
956
|
options?: never;
|
|
@@ -964,8 +966,8 @@ export interface paths {
|
|
|
964
966
|
cookie?: never;
|
|
965
967
|
};
|
|
966
968
|
/**
|
|
967
|
-
*
|
|
968
|
-
* @description
|
|
969
|
+
* Suggest the next free CIDR
|
|
970
|
+
* @description The returned value is a suggestion and is validated again when the subnet is created. It exists to avoid errors when computing the next free CIDR by hand.
|
|
969
971
|
*/
|
|
970
972
|
get: operations["suggest-subnet-cidr"];
|
|
971
973
|
put?: never;
|
|
@@ -987,8 +989,8 @@ export interface paths {
|
|
|
987
989
|
put?: never;
|
|
988
990
|
post?: never;
|
|
989
991
|
/**
|
|
990
|
-
*
|
|
991
|
-
* @description
|
|
992
|
+
* Delete a subnet
|
|
993
|
+
* @description Deletion is rejected while network interfaces remain in the subnet, or while a static route has a next hop inside its CIDR.
|
|
992
994
|
*/
|
|
993
995
|
delete: operations["delete-subnet"];
|
|
994
996
|
options?: never;
|
|
@@ -1003,12 +1005,12 @@ export interface paths {
|
|
|
1003
1005
|
path?: never;
|
|
1004
1006
|
cookie?: never;
|
|
1005
1007
|
};
|
|
1006
|
-
/**
|
|
1008
|
+
/** List security groups */
|
|
1007
1009
|
get: operations["list-security-groups"];
|
|
1008
1010
|
put?: never;
|
|
1009
1011
|
/**
|
|
1010
|
-
*
|
|
1011
|
-
* @description
|
|
1012
|
+
* Create a security group
|
|
1013
|
+
* @description A new security group carries one rule, permitting ICMP fragmentation-needed messages (type 3, code 4). Without it path MTU discovery fails, which presents as connections that establish and then stall on large packets.
|
|
1012
1014
|
*/
|
|
1013
1015
|
post: operations["create-security-group"];
|
|
1014
1016
|
delete?: never;
|
|
@@ -1024,20 +1026,20 @@ export interface paths {
|
|
|
1024
1026
|
path?: never;
|
|
1025
1027
|
cookie?: never;
|
|
1026
1028
|
};
|
|
1027
|
-
/**
|
|
1029
|
+
/** Retrieve a security group */
|
|
1028
1030
|
get: operations["get-security-group"];
|
|
1029
1031
|
put?: never;
|
|
1030
1032
|
post?: never;
|
|
1031
1033
|
/**
|
|
1032
|
-
*
|
|
1033
|
-
* @description
|
|
1034
|
+
* Delete a security group
|
|
1035
|
+
* @description The default security group cannot be deleted, as it is released with the private network. A security group still referenced by a network interface cannot be deleted either.
|
|
1034
1036
|
*/
|
|
1035
1037
|
delete: operations["delete-security-group"];
|
|
1036
1038
|
options?: never;
|
|
1037
1039
|
head?: never;
|
|
1038
1040
|
/**
|
|
1039
|
-
*
|
|
1040
|
-
* @description
|
|
1041
|
+
* Rename a security group
|
|
1042
|
+
* @description Changes the name only. Use the rule endpoints to change rules.
|
|
1041
1043
|
*/
|
|
1042
1044
|
patch: operations["rename-security-group"];
|
|
1043
1045
|
trace?: never;
|
|
@@ -1049,12 +1051,12 @@ export interface paths {
|
|
|
1049
1051
|
path?: never;
|
|
1050
1052
|
cookie?: never;
|
|
1051
1053
|
};
|
|
1052
|
-
/**
|
|
1054
|
+
/** List security group rules */
|
|
1053
1055
|
get: operations["list-security-group-rules"];
|
|
1054
1056
|
put?: never;
|
|
1055
1057
|
/**
|
|
1056
|
-
*
|
|
1057
|
-
* @description
|
|
1058
|
+
* Create a security group rule
|
|
1059
|
+
* @description Adding an identical rule twice is rejected. For that comparison `0.0.0.0/0`, `::/0` and an omitted value are treated as equivalent.
|
|
1058
1060
|
*/
|
|
1059
1061
|
post: operations["create-security-group-rule"];
|
|
1060
1062
|
delete?: never;
|
|
@@ -1073,7 +1075,7 @@ export interface paths {
|
|
|
1073
1075
|
get?: never;
|
|
1074
1076
|
put?: never;
|
|
1075
1077
|
post?: never;
|
|
1076
|
-
/**
|
|
1078
|
+
/** Delete a security group rule */
|
|
1077
1079
|
delete: operations["delete-security-group-rule"];
|
|
1078
1080
|
options?: never;
|
|
1079
1081
|
head?: never;
|
|
@@ -1087,14 +1089,14 @@ export interface paths {
|
|
|
1087
1089
|
path?: never;
|
|
1088
1090
|
cookie?: never;
|
|
1089
1091
|
};
|
|
1090
|
-
/**
|
|
1092
|
+
/** List snapshots */
|
|
1091
1093
|
get: operations["list-snapshots"];
|
|
1092
1094
|
put?: never;
|
|
1093
1095
|
/**
|
|
1094
|
-
*
|
|
1095
|
-
* @description
|
|
1096
|
+
* Create a snapshot
|
|
1097
|
+
* @description Disks attached to a running instance can be snapshotted. A snapshot records the state of the block device at a point in time and may be inconsistent at the file-system level, so run `sync` inside the instance first where the data matters.
|
|
1096
1098
|
*
|
|
1097
|
-
*
|
|
1099
|
+
* **A snapshot of a system disk cannot be used to revert that system disk**: reverting requires the disk to be detached, and a system disk cannot be detached. It can be used to create a new data disk. To preserve and restore an entire system, use a private image; for a copy that crosses availability zones and survives deletion of the disk, use a backup.
|
|
1098
1100
|
*/
|
|
1099
1101
|
post: operations["create-snapshot"];
|
|
1100
1102
|
delete?: never;
|
|
@@ -1110,15 +1112,15 @@ export interface paths {
|
|
|
1110
1112
|
path?: never;
|
|
1111
1113
|
cookie?: never;
|
|
1112
1114
|
};
|
|
1113
|
-
/**
|
|
1115
|
+
/** Retrieve a snapshot */
|
|
1114
1116
|
get: operations["get-snapshot"];
|
|
1115
1117
|
put?: never;
|
|
1116
1118
|
post?: never;
|
|
1117
|
-
/**
|
|
1119
|
+
/** Delete a snapshot */
|
|
1118
1120
|
delete: operations["delete-snapshot"];
|
|
1119
1121
|
options?: never;
|
|
1120
1122
|
head?: never;
|
|
1121
|
-
/**
|
|
1123
|
+
/** Rename a snapshot */
|
|
1122
1124
|
patch: operations["rename-snapshot"];
|
|
1123
1125
|
trace?: never;
|
|
1124
1126
|
};
|
|
@@ -1136,7 +1138,7 @@ export interface components {
|
|
|
1136
1138
|
status: number;
|
|
1137
1139
|
};
|
|
1138
1140
|
BackupResource: {
|
|
1139
|
-
/** @description
|
|
1141
|
+
/** @description Availability zone of the source disk. A restore may target another zone in the same region */
|
|
1140
1142
|
availability_zone: string;
|
|
1141
1143
|
/** Format: date-time */
|
|
1142
1144
|
created_at: string;
|
|
@@ -1146,12 +1148,12 @@ export interface components {
|
|
|
1146
1148
|
region_code: string;
|
|
1147
1149
|
/**
|
|
1148
1150
|
* Format: int64
|
|
1149
|
-
* @description
|
|
1151
|
+
* @description Capacity of the source disk when the backup was created. A restored disk cannot be smaller than this
|
|
1150
1152
|
*/
|
|
1151
1153
|
size_gb: number;
|
|
1152
1154
|
/**
|
|
1153
1155
|
* Format: uuid
|
|
1154
|
-
* @description
|
|
1156
|
+
* @description The disk this backup was taken from. The backup remains usable after that disk is deleted
|
|
1155
1157
|
*/
|
|
1156
1158
|
source_disk_id: string;
|
|
1157
1159
|
/** @enum {string} */
|
|
@@ -1171,29 +1173,29 @@ export interface components {
|
|
|
1171
1173
|
RestoreBackupRequestBody: {
|
|
1172
1174
|
/**
|
|
1173
1175
|
* Format: uuid
|
|
1174
|
-
* @description
|
|
1176
|
+
* @description May differ from the availability zone of the source disk, but must be in the same region
|
|
1175
1177
|
*/
|
|
1176
1178
|
disk_type_id: string;
|
|
1177
1179
|
name: string;
|
|
1178
1180
|
/**
|
|
1179
1181
|
* Format: int64
|
|
1180
|
-
* @description
|
|
1182
|
+
* @description Matches the size of the backup when omitted. When given, it must not be smaller than the backup
|
|
1181
1183
|
*/
|
|
1182
1184
|
size_gb?: number;
|
|
1183
1185
|
};
|
|
1184
1186
|
DiskResource: {
|
|
1185
1187
|
attached_instance_id: string | null;
|
|
1186
|
-
/** @description
|
|
1188
|
+
/** @description Availability zone the disk actually resides in. An instance must be in the same zone to attach it */
|
|
1187
1189
|
availability_zone: string;
|
|
1188
1190
|
/** Format: date-time */
|
|
1189
1191
|
created_at: string;
|
|
1190
|
-
/** @description
|
|
1192
|
+
/** @description Device name assigned by the system, as seen inside the instance */
|
|
1191
1193
|
device: string | null;
|
|
1192
1194
|
/** Format: uuid */
|
|
1193
1195
|
disk_type_id: string;
|
|
1194
1196
|
/** Format: uuid */
|
|
1195
1197
|
id: string;
|
|
1196
|
-
/** @description
|
|
1198
|
+
/** @description A system disk is released with its instance and can be neither detached nor deleted individually */
|
|
1197
1199
|
is_system: boolean;
|
|
1198
1200
|
name: string;
|
|
1199
1201
|
region_code: string;
|
|
@@ -1234,14 +1236,14 @@ export interface components {
|
|
|
1234
1236
|
os_family: string;
|
|
1235
1237
|
os_version: string;
|
|
1236
1238
|
region_code: string;
|
|
1237
|
-
/** @description
|
|
1239
|
+
/** @description False means a new password can only be set by rebuilding an instance created from this image */
|
|
1238
1240
|
supports_password_reset: boolean;
|
|
1239
1241
|
};
|
|
1240
1242
|
ImageListResponseBody: {
|
|
1241
1243
|
items: components["schemas"]["ImageResource"][] | null;
|
|
1242
1244
|
};
|
|
1243
1245
|
InstanceTypeResource: {
|
|
1244
|
-
/** @description
|
|
1246
|
+
/** @description Availability zone of this instance type. A disk must be in the same zone to be attached */
|
|
1245
1247
|
availability_zone_code: string;
|
|
1246
1248
|
/** Format: uuid */
|
|
1247
1249
|
id: string;
|
|
@@ -1287,7 +1289,7 @@ export interface components {
|
|
|
1287
1289
|
size_gb: number;
|
|
1288
1290
|
/**
|
|
1289
1291
|
* Format: uuid
|
|
1290
|
-
* @description
|
|
1292
|
+
* @description Restore from this snapshot. When given, the capacity need only be no smaller than the snapshot
|
|
1291
1293
|
*/
|
|
1292
1294
|
snapshot_id?: string;
|
|
1293
1295
|
};
|
|
@@ -1297,14 +1299,14 @@ export interface components {
|
|
|
1297
1299
|
ResizeDiskRequestBody: {
|
|
1298
1300
|
/**
|
|
1299
1301
|
* Format: int64
|
|
1300
|
-
* @description
|
|
1302
|
+
* @description Must be larger than the current capacity
|
|
1301
1303
|
*/
|
|
1302
1304
|
size_gb: number;
|
|
1303
1305
|
};
|
|
1304
1306
|
RevertDiskRequestBody: {
|
|
1305
1307
|
/**
|
|
1306
1308
|
* Format: uuid
|
|
1307
|
-
* @description
|
|
1309
|
+
* @description Must be the most recent snapshot of the disk
|
|
1308
1310
|
*/
|
|
1309
1311
|
snapshot_id: string;
|
|
1310
1312
|
};
|
|
@@ -1322,7 +1324,7 @@ export interface components {
|
|
|
1322
1324
|
id: string;
|
|
1323
1325
|
region_code: string;
|
|
1324
1326
|
/**
|
|
1325
|
-
* @description idle
|
|
1327
|
+
* @description `idle` means the address is not bound to a network interface
|
|
1326
1328
|
* @enum {string}
|
|
1327
1329
|
*/
|
|
1328
1330
|
status: "idle" | "bound";
|
|
@@ -1331,7 +1333,7 @@ export interface components {
|
|
|
1331
1333
|
items: components["schemas"]["FloatingIPResource"][] | null;
|
|
1332
1334
|
};
|
|
1333
1335
|
AllocateFloatingIPRequestBody: {
|
|
1334
|
-
/** @description
|
|
1336
|
+
/** @description The address to allocate. Allocated by the platform when omitted */
|
|
1335
1337
|
address?: string;
|
|
1336
1338
|
/** Format: uuid */
|
|
1337
1339
|
private_network_id: string;
|
|
@@ -1339,7 +1341,7 @@ export interface components {
|
|
|
1339
1341
|
SetBandwidthRequestBody: {
|
|
1340
1342
|
/**
|
|
1341
1343
|
* Format: int64
|
|
1342
|
-
* @description
|
|
1344
|
+
* @description Applied to both directions
|
|
1343
1345
|
*/
|
|
1344
1346
|
mbps: number;
|
|
1345
1347
|
};
|
|
@@ -1351,47 +1353,54 @@ export interface components {
|
|
|
1351
1353
|
availability_zone: string;
|
|
1352
1354
|
/** Format: date-time */
|
|
1353
1355
|
created_at: string;
|
|
1354
|
-
/** @description
|
|
1356
|
+
/** @description Hostname inside the instance; equals the instance id */
|
|
1355
1357
|
hostname: string;
|
|
1356
1358
|
/** Format: uuid */
|
|
1357
1359
|
id: string;
|
|
1358
1360
|
/**
|
|
1359
1361
|
* Format: uuid
|
|
1360
|
-
* @description
|
|
1362
|
+
* @description Non-empty when the instance was created from a platform image
|
|
1361
1363
|
*/
|
|
1362
1364
|
image_id: string | null;
|
|
1363
1365
|
/**
|
|
1364
1366
|
* Format: uuid
|
|
1365
|
-
* @description
|
|
1367
|
+
* @description The instance type in effect, and the basis for billing
|
|
1366
1368
|
*/
|
|
1367
1369
|
instance_type_id: string;
|
|
1368
|
-
/** @description
|
|
1370
|
+
/** @description IPv6 address of the primary network interface. Assigned automatically once IPv6 is enabled on the private network */
|
|
1369
1371
|
ipv6_address: string | null;
|
|
1370
1372
|
name: string;
|
|
1371
1373
|
/**
|
|
1372
1374
|
* Format: uuid
|
|
1373
|
-
* @description
|
|
1375
|
+
* @description Non-empty while a resize awaits confirmation. Confirming puts this type into effect, reverting discards it
|
|
1374
1376
|
*/
|
|
1375
1377
|
pending_instance_type_id: string | null;
|
|
1376
1378
|
/**
|
|
1377
1379
|
* Format: uuid
|
|
1378
|
-
* @description
|
|
1380
|
+
* @description Non-empty when the instance was created from a private image
|
|
1379
1381
|
*/
|
|
1380
1382
|
private_image_id: string | null;
|
|
1381
|
-
/** @description
|
|
1383
|
+
/** @description Private address of the instance */
|
|
1382
1384
|
private_ip: string | null;
|
|
1383
|
-
/** @description
|
|
1385
|
+
/** @description Private network of the primary network interface */
|
|
1384
1386
|
private_network_id: string | null;
|
|
1385
|
-
/** @description
|
|
1387
|
+
/** @description Floating IPv4 addresses bound to the primary network interface; an empty array when none are bound */
|
|
1386
1388
|
public_ips: string[] | null;
|
|
1387
1389
|
region_code: string;
|
|
1388
|
-
/**
|
|
1389
|
-
|
|
1390
|
-
|
|
1390
|
+
/**
|
|
1391
|
+
* @description Only `running` and `stopped` accept commands. Every other value means the instance is changing, and start, stop, reboot, resize, rebuild and password reset are all rejected.
|
|
1392
|
+
*
|
|
1393
|
+
* `transitioning` is the fallback for a change that falls into none of the categories above. It does not indicate an error; keep polling.
|
|
1394
|
+
*
|
|
1395
|
+
* `resize_verifying` is not transient: the instance is running on the new size and stays there until the resize is confirmed or reverted, with both sizes billed in the meantime.
|
|
1396
|
+
* @enum {string}
|
|
1397
|
+
*/
|
|
1398
|
+
status: "provisioning" | "running" | "stopped" | "starting" | "stopping" | "rebooting" | "transitioning" | "resizing" | "resize_verifying" | "error" | "deleting" | "suspended";
|
|
1399
|
+
/** @description Subnet of the primary network interface */
|
|
1391
1400
|
subnet_id: string | null;
|
|
1392
1401
|
/**
|
|
1393
1402
|
* Format: date-time
|
|
1394
|
-
* @description
|
|
1403
|
+
* @description Non-empty once the platform has suspended the instance, which must be lifted before any operation
|
|
1395
1404
|
*/
|
|
1396
1405
|
suspended_at: string | null;
|
|
1397
1406
|
/** Format: date-time */
|
|
@@ -1403,50 +1412,50 @@ export interface components {
|
|
|
1403
1412
|
LaunchInstanceRequestBody: {
|
|
1404
1413
|
/**
|
|
1405
1414
|
* Format: int64
|
|
1406
|
-
* @description
|
|
1415
|
+
* @description Number of instances to create; 1 when omitted. Names are numbered automatically for several
|
|
1407
1416
|
*/
|
|
1408
1417
|
count?: number;
|
|
1409
|
-
/** @description
|
|
1418
|
+
/** @description Have the platform generate a random password, returned only in this response */
|
|
1410
1419
|
generate_password?: boolean;
|
|
1411
1420
|
/**
|
|
1412
1421
|
* Format: uuid
|
|
1413
|
-
* @description
|
|
1422
|
+
* @description A platform image. Exactly one of this and `private_image_id`
|
|
1414
1423
|
*/
|
|
1415
1424
|
image_id?: string;
|
|
1416
1425
|
/** Format: uuid */
|
|
1417
1426
|
instance_type_id: string;
|
|
1418
1427
|
name: string;
|
|
1419
|
-
/** @description
|
|
1428
|
+
/** @description Root password. Only the SSH public keys of the project are used when omitted */
|
|
1420
1429
|
password?: string;
|
|
1421
1430
|
/**
|
|
1422
1431
|
* Format: uuid
|
|
1423
|
-
* @description
|
|
1432
|
+
* @description Use an existing network interface, which may already have a floating IP bound. Exactly one of this and `subnet_id`; only one instance can be created when it is used
|
|
1424
1433
|
*/
|
|
1425
1434
|
port_id?: string;
|
|
1426
1435
|
/**
|
|
1427
1436
|
* Format: uuid
|
|
1428
|
-
* @description
|
|
1437
|
+
* @description A private image. Exactly one of this and `image_id`
|
|
1429
1438
|
*/
|
|
1430
1439
|
private_image_id?: string;
|
|
1431
1440
|
/**
|
|
1432
1441
|
* Format: int64
|
|
1433
|
-
* @description
|
|
1442
|
+
* @description System disk capacity in GB. Chosen automatically from the requirement of the image and the platform minimum when omitted
|
|
1434
1443
|
*/
|
|
1435
1444
|
root_disk_gb?: number;
|
|
1436
|
-
/** @description
|
|
1445
|
+
/** @description Required when a primary network interface is created, at least one; the default security group is not applied automatically. Ignored together with `port_id`, as the security groups of that interface were fixed when it was created */
|
|
1437
1446
|
security_group_ids?: string[] | null;
|
|
1438
1447
|
/**
|
|
1439
1448
|
* Format: uuid
|
|
1440
|
-
* @description
|
|
1449
|
+
* @description Create the primary network interface in this subnet. Exactly one of this and `port_id`
|
|
1441
1450
|
*/
|
|
1442
1451
|
subnet_id?: string;
|
|
1443
1452
|
};
|
|
1444
1453
|
LaunchInstanceResponseBody: {
|
|
1445
|
-
/** @description
|
|
1454
|
+
/** @description Non-empty when only some of the instances were created, stating why the sequence stopped */
|
|
1446
1455
|
failure: string | null;
|
|
1447
|
-
/** @description
|
|
1456
|
+
/** @description Returned in request order; an array even for a single instance */
|
|
1448
1457
|
instances: components["schemas"]["InstanceResource"][] | null;
|
|
1449
|
-
/** @description
|
|
1458
|
+
/** @description Returned only in this response; store it immediately. All instances of a batch share it */
|
|
1450
1459
|
password: string;
|
|
1451
1460
|
};
|
|
1452
1461
|
RenameInstanceRequestBody: {
|
|
@@ -1455,50 +1464,50 @@ export interface components {
|
|
|
1455
1464
|
ActOnInstanceRequestBody: {
|
|
1456
1465
|
/** @enum {string} */
|
|
1457
1466
|
action: "start" | "stop" | "reboot";
|
|
1458
|
-
/** @description
|
|
1467
|
+
/** @description Applies to `reboot` only. A forced reboot does not wait for the operating system to shut down and unwritten data is lost; use it when the system is unresponsive */
|
|
1459
1468
|
force?: boolean;
|
|
1460
1469
|
};
|
|
1461
1470
|
ConsoleResponseBody: {
|
|
1462
|
-
/** @description
|
|
1471
|
+
/** @description Connection address of the remote console; single-use and expires within minutes */
|
|
1463
1472
|
console_url: string;
|
|
1464
1473
|
};
|
|
1465
1474
|
ConsoleOutputResponseBody: {
|
|
1466
|
-
/** @description
|
|
1475
|
+
/** @description Raw text of the console output, in the same line order as inside the instance */
|
|
1467
1476
|
output: string;
|
|
1468
1477
|
};
|
|
1469
1478
|
ResetPasswordRequestBody: {
|
|
1470
|
-
/** @description
|
|
1479
|
+
/** @description Have the platform generate a random password, returned only in this response */
|
|
1471
1480
|
generate_password?: boolean;
|
|
1472
|
-
/** @description
|
|
1481
|
+
/** @description New root password. Exactly one of this and `generate_password` */
|
|
1473
1482
|
password?: string;
|
|
1474
1483
|
};
|
|
1475
1484
|
ResetPasswordResponseBody: {
|
|
1476
|
-
/** @description
|
|
1485
|
+
/** @description The password generated by the platform, returned only in this response. Empty when the password was supplied in the request */
|
|
1477
1486
|
password: string;
|
|
1478
1487
|
};
|
|
1479
1488
|
RebuildInstanceRequestBody: {
|
|
1480
1489
|
generate_password?: boolean;
|
|
1481
1490
|
/**
|
|
1482
1491
|
* Format: uuid
|
|
1483
|
-
* @description
|
|
1492
|
+
* @description A platform image. Exactly one of this and `private_image_id`
|
|
1484
1493
|
*/
|
|
1485
1494
|
image_id?: string;
|
|
1486
1495
|
password?: string;
|
|
1487
1496
|
/**
|
|
1488
1497
|
* Format: uuid
|
|
1489
|
-
* @description
|
|
1498
|
+
* @description A private image. Exactly one of this and `image_id`
|
|
1490
1499
|
*/
|
|
1491
1500
|
private_image_id?: string;
|
|
1492
1501
|
};
|
|
1493
1502
|
RebuildInstanceResponseBody: {
|
|
1494
1503
|
instance: components["schemas"]["InstanceResource"];
|
|
1495
|
-
/** @description
|
|
1504
|
+
/** @description Returned only in this response; store it immediately */
|
|
1496
1505
|
password: string;
|
|
1497
1506
|
};
|
|
1498
1507
|
ResizeInstanceRequestBody: {
|
|
1499
1508
|
/**
|
|
1500
1509
|
* Format: uuid
|
|
1501
|
-
* @description
|
|
1510
|
+
* @description Must be in the same region and availability zone as the current instance type
|
|
1502
1511
|
*/
|
|
1503
1512
|
instance_type_id: string;
|
|
1504
1513
|
};
|
|
@@ -1515,14 +1524,14 @@ export interface components {
|
|
|
1515
1524
|
/** Format: uuid */
|
|
1516
1525
|
id: string;
|
|
1517
1526
|
ipv6_address: string | null;
|
|
1518
|
-
/** @description
|
|
1527
|
+
/** @description A primary network interface is created and released with its instance and cannot be detached individually */
|
|
1519
1528
|
is_primary: boolean;
|
|
1520
1529
|
mac: string | null;
|
|
1521
1530
|
name: string;
|
|
1522
1531
|
private_ip: string | null;
|
|
1523
1532
|
/** Format: uuid */
|
|
1524
1533
|
private_network_id: string;
|
|
1525
|
-
/** @description
|
|
1534
|
+
/** @description Floating IPv4 addresses bound to this network interface; an empty array when none are bound */
|
|
1526
1535
|
public_ips: string[] | null;
|
|
1527
1536
|
/** Format: uuid */
|
|
1528
1537
|
subnet_id: string;
|
|
@@ -1535,24 +1544,24 @@ export interface components {
|
|
|
1535
1544
|
port_id: string;
|
|
1536
1545
|
};
|
|
1537
1546
|
OperationLogResource: {
|
|
1538
|
-
/** @description
|
|
1547
|
+
/** @description Name of the operation; matches the operation id of the endpoint */
|
|
1539
1548
|
action: string;
|
|
1540
|
-
/** @description
|
|
1549
|
+
/** @description The user who initiated the operation. Empty when the platform performed it */
|
|
1541
1550
|
actor: string | null;
|
|
1542
|
-
/** @description
|
|
1551
|
+
/** @description True when the operation was performed by the platform */
|
|
1543
1552
|
by_platform: boolean;
|
|
1544
1553
|
/** Format: date-time */
|
|
1545
1554
|
created_at: string;
|
|
1546
|
-
/** @description
|
|
1555
|
+
/** @description Brief reason for the failure */
|
|
1547
1556
|
failure: string | null;
|
|
1548
1557
|
/** Format: uuid */
|
|
1549
1558
|
id: string;
|
|
1550
|
-
/** @description
|
|
1559
|
+
/** @description Path and query parameters of the request. Fields such as passwords are redacted */
|
|
1551
1560
|
payload: {
|
|
1552
1561
|
[key: string]: unknown;
|
|
1553
1562
|
};
|
|
1554
1563
|
region_code: string | null;
|
|
1555
|
-
/** @description
|
|
1564
|
+
/** @description Empty for create operations: the id of the new resource is in the response, not in the request path */
|
|
1556
1565
|
subject_id: string;
|
|
1557
1566
|
subject_type: string;
|
|
1558
1567
|
succeeded: boolean;
|
|
@@ -1564,9 +1573,9 @@ export interface components {
|
|
|
1564
1573
|
};
|
|
1565
1574
|
CreatePortRequestBody: {
|
|
1566
1575
|
name?: string;
|
|
1567
|
-
/** @description
|
|
1576
|
+
/** @description The private address to assign. Allocated automatically when omitted */
|
|
1568
1577
|
private_ip?: string;
|
|
1569
|
-
/** @description
|
|
1578
|
+
/** @description At least one, and all must belong to the same private network */
|
|
1570
1579
|
security_group_ids: string[] | null;
|
|
1571
1580
|
/** Format: uuid */
|
|
1572
1581
|
subnet_id: string;
|
|
@@ -1575,38 +1584,38 @@ export interface components {
|
|
|
1575
1584
|
architecture: string;
|
|
1576
1585
|
/** Format: date-time */
|
|
1577
1586
|
created_at: string;
|
|
1578
|
-
/** @description
|
|
1587
|
+
/** @description Reason the capture failed; non-empty only when `status` is `error` */
|
|
1579
1588
|
failure: string | null;
|
|
1580
1589
|
/** Format: uuid */
|
|
1581
1590
|
id: string;
|
|
1582
1591
|
/**
|
|
1583
1592
|
* Format: int64
|
|
1584
|
-
* @description
|
|
1593
|
+
* @description The system disk of an instance created from this image cannot be smaller than this
|
|
1585
1594
|
*/
|
|
1586
1595
|
min_disk_gb: number;
|
|
1587
1596
|
/**
|
|
1588
1597
|
* Format: int64
|
|
1589
|
-
* @description
|
|
1598
|
+
* @description The instance type of an instance created from this image must have at least this much memory
|
|
1590
1599
|
*/
|
|
1591
1600
|
min_ram_mb: number;
|
|
1592
1601
|
name: string;
|
|
1593
1602
|
os_family: string;
|
|
1594
1603
|
os_version: string;
|
|
1595
|
-
/** @description
|
|
1604
|
+
/** @description An image can only be used in the region that holds it */
|
|
1596
1605
|
region_code: string;
|
|
1597
1606
|
/**
|
|
1598
1607
|
* Format: int64
|
|
1599
|
-
* @description
|
|
1608
|
+
* @description Storage occupied by the image; 0 until the capture completes
|
|
1600
1609
|
*/
|
|
1601
1610
|
size_bytes: number;
|
|
1602
1611
|
/**
|
|
1603
1612
|
* Format: uuid
|
|
1604
|
-
* @description
|
|
1613
|
+
* @description The instance this image was captured from. The image remains usable after that instance is released
|
|
1605
1614
|
*/
|
|
1606
1615
|
source_instance_id: string | null;
|
|
1607
1616
|
/** @enum {string} */
|
|
1608
1617
|
status: "provisioning" | "uploading" | "available" | "deleting" | "error";
|
|
1609
|
-
/** @description
|
|
1618
|
+
/** @description False means a new password can only be set by rebuilding an instance created from this image */
|
|
1610
1619
|
supports_password_reset: boolean;
|
|
1611
1620
|
};
|
|
1612
1621
|
PrivateImageListResponseBody: {
|
|
@@ -1615,7 +1624,7 @@ export interface components {
|
|
|
1615
1624
|
CreatePrivateImageRequestBody: {
|
|
1616
1625
|
/**
|
|
1617
1626
|
* Format: uuid
|
|
1618
|
-
* @description
|
|
1627
|
+
* @description Captured from the system disk of this instance; data disks are not included
|
|
1619
1628
|
*/
|
|
1620
1629
|
instance_id: string;
|
|
1621
1630
|
name: string;
|
|
@@ -1641,7 +1650,7 @@ export interface components {
|
|
|
1641
1650
|
items: components["schemas"]["PrivateNetworkResource"][] | null;
|
|
1642
1651
|
};
|
|
1643
1652
|
CreatePrivateNetworkRequestBody: {
|
|
1644
|
-
/** @description
|
|
1653
|
+
/** @description Must be an RFC 1918 private CIDR with a prefix length between /8 and /24, for example `10.0.0.0/16` */
|
|
1645
1654
|
cidr: string;
|
|
1646
1655
|
name: string;
|
|
1647
1656
|
region_code: string;
|
|
@@ -1650,11 +1659,11 @@ export interface components {
|
|
|
1650
1659
|
name: string;
|
|
1651
1660
|
};
|
|
1652
1661
|
IPv6ResponseBody: {
|
|
1653
|
-
/** @description
|
|
1662
|
+
/** @description The allocated /64 prefix; empty while IPv6 is disabled */
|
|
1654
1663
|
cidr: string;
|
|
1655
1664
|
enabled: boolean;
|
|
1656
1665
|
/**
|
|
1657
|
-
* @description
|
|
1666
|
+
* @description `active` means IPv6 is fully available
|
|
1658
1667
|
* @enum {string}
|
|
1659
1668
|
*/
|
|
1660
1669
|
status: "pending" | "active" | "draining";
|
|
@@ -1673,9 +1682,9 @@ export interface components {
|
|
|
1673
1682
|
};
|
|
1674
1683
|
CreateRouteRequestBody: {
|
|
1675
1684
|
description?: string;
|
|
1676
|
-
/** @description
|
|
1685
|
+
/** @description Destination CIDR. It cannot be `0.0.0.0/0`, nor the CIDR of a subnet of this network */
|
|
1677
1686
|
destination: string;
|
|
1678
|
-
/** @description
|
|
1687
|
+
/** @description Private address of an instance; must fall inside a subnet of this private network */
|
|
1679
1688
|
nexthop: string;
|
|
1680
1689
|
};
|
|
1681
1690
|
SubnetResource: {
|
|
@@ -1696,12 +1705,12 @@ export interface components {
|
|
|
1696
1705
|
items: components["schemas"]["SubnetResource"][] | null;
|
|
1697
1706
|
};
|
|
1698
1707
|
CreateSubnetRequestBody: {
|
|
1699
|
-
/** @description
|
|
1708
|
+
/** @description Must fall inside the CIDR of the private network and must not overlap an existing subnet */
|
|
1700
1709
|
cidr: string;
|
|
1701
1710
|
name: string;
|
|
1702
1711
|
};
|
|
1703
1712
|
NextFreeCidrResponseBody: {
|
|
1704
|
-
/** @description
|
|
1713
|
+
/** @description Empty when the private network has no free CIDR left for that prefix length */
|
|
1705
1714
|
cidr: string;
|
|
1706
1715
|
};
|
|
1707
1716
|
SecurityGroupResource: {
|
|
@@ -1710,7 +1719,7 @@ export interface components {
|
|
|
1710
1719
|
description: string;
|
|
1711
1720
|
/** Format: uuid */
|
|
1712
1721
|
id: string;
|
|
1713
|
-
/** @description
|
|
1722
|
+
/** @description The default security group is released with its private network and cannot be deleted individually */
|
|
1714
1723
|
is_default: boolean;
|
|
1715
1724
|
name: string;
|
|
1716
1725
|
/** Format: uuid */
|
|
@@ -1737,12 +1746,12 @@ export interface components {
|
|
|
1737
1746
|
id: string;
|
|
1738
1747
|
/**
|
|
1739
1748
|
* Format: int64
|
|
1740
|
-
* @description ICMP
|
|
1749
|
+
* @description Denotes the ICMP code rather than a port when the protocol is ICMP
|
|
1741
1750
|
*/
|
|
1742
1751
|
port_range_max: number | null;
|
|
1743
1752
|
/**
|
|
1744
1753
|
* Format: int64
|
|
1745
|
-
* @description ICMP
|
|
1754
|
+
* @description Denotes the ICMP type rather than a port when the protocol is ICMP
|
|
1746
1755
|
*/
|
|
1747
1756
|
port_range_min: number | null;
|
|
1748
1757
|
protocol: string | null;
|
|
@@ -1759,21 +1768,21 @@ export interface components {
|
|
|
1759
1768
|
ethertype: "IPv4" | "IPv6";
|
|
1760
1769
|
/**
|
|
1761
1770
|
* Format: int64
|
|
1762
|
-
* @description ICMP
|
|
1771
|
+
* @description Denotes the ICMP code (0–255) rather than a port when the protocol is ICMP
|
|
1763
1772
|
*/
|
|
1764
1773
|
port_range_max?: number | null;
|
|
1765
1774
|
/**
|
|
1766
1775
|
* Format: int64
|
|
1767
|
-
* @description ICMP
|
|
1776
|
+
* @description Denotes the ICMP type (0–255) rather than a port when the protocol is ICMP
|
|
1768
1777
|
*/
|
|
1769
1778
|
port_range_min?: number | null;
|
|
1770
|
-
/** @description
|
|
1779
|
+
/** @description For example `tcp`, `udp`, `icmp` or `ipv6-icmp`. All protocols when omitted */
|
|
1771
1780
|
protocol?: string;
|
|
1772
|
-
/** @description
|
|
1781
|
+
/** @description Equivalent to `0.0.0.0/0` or `::/0` when omitted */
|
|
1773
1782
|
remote_ip_prefix?: string;
|
|
1774
1783
|
};
|
|
1775
1784
|
SnapshotResource: {
|
|
1776
|
-
/** @description
|
|
1785
|
+
/** @description A disk restored from this snapshot must reside in this availability zone */
|
|
1777
1786
|
availability_zone: string;
|
|
1778
1787
|
/** Format: date-time */
|
|
1779
1788
|
created_at: string;
|
|
@@ -1785,7 +1794,7 @@ export interface components {
|
|
|
1785
1794
|
region_code: string;
|
|
1786
1795
|
/**
|
|
1787
1796
|
* Format: int64
|
|
1788
|
-
* @description
|
|
1797
|
+
* @description Capacity of the source disk when the snapshot was created. A disk restored from it cannot be smaller
|
|
1789
1798
|
*/
|
|
1790
1799
|
size_gb: number;
|
|
1791
1800
|
/** @enum {string} */
|
|
@@ -1817,7 +1826,7 @@ export interface operations {
|
|
|
1817
1826
|
"list-backups": {
|
|
1818
1827
|
parameters: {
|
|
1819
1828
|
query?: {
|
|
1820
|
-
/** @description
|
|
1829
|
+
/** @description Return only the backups of this disk */
|
|
1821
1830
|
disk_id?: string;
|
|
1822
1831
|
};
|
|
1823
1832
|
header?: never;
|
|
@@ -2166,7 +2175,7 @@ export interface operations {
|
|
|
2166
2175
|
parameters: {
|
|
2167
2176
|
query?: {
|
|
2168
2177
|
region_code?: string;
|
|
2169
|
-
/** @description
|
|
2178
|
+
/** @description Supplied together with `region_code` to filter attachable disks */
|
|
2170
2179
|
availability_zone?: string;
|
|
2171
2180
|
};
|
|
2172
2181
|
header?: never;
|
|
@@ -2842,7 +2851,7 @@ export interface operations {
|
|
|
2842
2851
|
"get-instance-console-output": {
|
|
2843
2852
|
parameters: {
|
|
2844
2853
|
query?: {
|
|
2845
|
-
/** @description
|
|
2854
|
+
/** @description Number of trailing lines to return; 0 returns the entire output */
|
|
2846
2855
|
lines?: number;
|
|
2847
2856
|
};
|
|
2848
2857
|
header?: never;
|
|
@@ -3306,7 +3315,7 @@ export interface operations {
|
|
|
3306
3315
|
"list-operation-logs": {
|
|
3307
3316
|
parameters: {
|
|
3308
3317
|
query?: {
|
|
3309
|
-
/** @description
|
|
3318
|
+
/** @description Return a single kind of operation; the value matches the operation id of the endpoint */
|
|
3310
3319
|
action?: string;
|
|
3311
3320
|
limit?: number;
|
|
3312
3321
|
offset?: number;
|
|
@@ -3431,7 +3440,7 @@ export interface operations {
|
|
|
3431
3440
|
"list-private-images": {
|
|
3432
3441
|
parameters: {
|
|
3433
3442
|
query?: {
|
|
3434
|
-
/** @description
|
|
3443
|
+
/** @description Return only the images of this region. An image can only be used in the region that holds it */
|
|
3435
3444
|
region_code?: string;
|
|
3436
3445
|
};
|
|
3437
3446
|
header?: never;
|
|
@@ -3591,7 +3600,7 @@ export interface operations {
|
|
|
3591
3600
|
"list-private-networks": {
|
|
3592
3601
|
parameters: {
|
|
3593
3602
|
query?: {
|
|
3594
|
-
/** @description
|
|
3603
|
+
/** @description Returns every region when omitted */
|
|
3595
3604
|
region_code?: string;
|
|
3596
3605
|
};
|
|
3597
3606
|
header?: never;
|
|
@@ -4068,7 +4077,7 @@ export interface operations {
|
|
|
4068
4077
|
parameters: {
|
|
4069
4078
|
query?: {
|
|
4070
4079
|
region_code?: string;
|
|
4071
|
-
/** @description
|
|
4080
|
+
/** @description Return only the security groups of this private network */
|
|
4072
4081
|
private_network_id?: string;
|
|
4073
4082
|
};
|
|
4074
4083
|
header?: never;
|
|
@@ -4324,7 +4333,7 @@ export interface operations {
|
|
|
4324
4333
|
"list-snapshots": {
|
|
4325
4334
|
parameters: {
|
|
4326
4335
|
query?: {
|
|
4327
|
-
/** @description
|
|
4336
|
+
/** @description Return only the snapshots of this disk */
|
|
4328
4337
|
disk_id?: string;
|
|
4329
4338
|
};
|
|
4330
4339
|
header?: never;
|