@leaflow/sdk 0.62.0 → 0.64.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 +10 -6
- package/dist/fabric/v1/schema.d.ts +11 -12
- package/dist/storage/v1/index.d.ts +3 -53
- package/dist/storage/v1/schema.d.ts +228 -1172
- package/package.json +1 -1
|
@@ -3,72 +3,6 @@
|
|
|
3
3
|
* Do not make direct changes to the file.
|
|
4
4
|
*/
|
|
5
5
|
export interface paths {
|
|
6
|
-
"/api/v1/backups": {
|
|
7
|
-
parameters: {
|
|
8
|
-
query?: never;
|
|
9
|
-
header?: never;
|
|
10
|
-
path?: never;
|
|
11
|
-
cookie?: never;
|
|
12
|
-
};
|
|
13
|
-
/** List backups */
|
|
14
|
-
get: operations["list-backups"];
|
|
15
|
-
put?: never;
|
|
16
|
-
/**
|
|
17
|
-
* Create a backup
|
|
18
|
-
* @description Creates a Billing order, including for metered pricing. The price must belong to the resource’s Billing Plan; applicable contract pricing is resolved by Billing. Technical capacity is checked before sellable quota is reserved. Provisioning continues automatically after payment; do not submit a new purchase after paying. Reuse the original idempotency key after an uncertain response.
|
|
19
|
-
*/
|
|
20
|
-
post: operations["create-backup"];
|
|
21
|
-
delete?: never;
|
|
22
|
-
options?: never;
|
|
23
|
-
head?: never;
|
|
24
|
-
patch?: never;
|
|
25
|
-
trace?: never;
|
|
26
|
-
};
|
|
27
|
-
"/api/v1/backups/{backupId}": {
|
|
28
|
-
parameters: {
|
|
29
|
-
query?: never;
|
|
30
|
-
header?: never;
|
|
31
|
-
path?: never;
|
|
32
|
-
cookie?: never;
|
|
33
|
-
};
|
|
34
|
-
/**
|
|
35
|
-
* Retrieve a backup
|
|
36
|
-
* @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.
|
|
37
|
-
*/
|
|
38
|
-
get: operations["get-backup"];
|
|
39
|
-
put?: never;
|
|
40
|
-
post?: never;
|
|
41
|
-
/**
|
|
42
|
-
* Delete a backup
|
|
43
|
-
* @description Independent of the source disk: deletion succeeds whether or not that disk still exists.
|
|
44
|
-
*/
|
|
45
|
-
delete: operations["delete-backup"];
|
|
46
|
-
options?: never;
|
|
47
|
-
head?: never;
|
|
48
|
-
/** Rename a backup */
|
|
49
|
-
patch: operations["rename-backup"];
|
|
50
|
-
trace?: never;
|
|
51
|
-
};
|
|
52
|
-
"/api/v1/backups/{backupId}/restore": {
|
|
53
|
-
parameters: {
|
|
54
|
-
query?: never;
|
|
55
|
-
header?: never;
|
|
56
|
-
path?: never;
|
|
57
|
-
cookie?: never;
|
|
58
|
-
};
|
|
59
|
-
get?: never;
|
|
60
|
-
put?: never;
|
|
61
|
-
/**
|
|
62
|
-
* Restore from a backup
|
|
63
|
-
* @description Creates a Billing order, including for metered pricing. The price must belong to the resource’s Billing Plan; applicable contract pricing is resolved by Billing. Technical capacity is checked before sellable quota is reserved. Provisioning continues automatically after payment; do not submit a new purchase after paying. Reuse the original idempotency key after an uncertain response.
|
|
64
|
-
*/
|
|
65
|
-
post: operations["restore-backup"];
|
|
66
|
-
delete?: never;
|
|
67
|
-
options?: never;
|
|
68
|
-
head?: never;
|
|
69
|
-
patch?: never;
|
|
70
|
-
trace?: never;
|
|
71
|
-
};
|
|
72
6
|
"/api/v1/disk-types": {
|
|
73
7
|
parameters: {
|
|
74
8
|
query?: never;
|
|
@@ -76,10 +10,7 @@ export interface paths {
|
|
|
76
10
|
path?: never;
|
|
77
11
|
cookie?: never;
|
|
78
12
|
};
|
|
79
|
-
/**
|
|
80
|
-
* List disk types on sale
|
|
81
|
-
* @description Only disk types currently on sale are listed. A withdrawn one disappears from here and can no longer be bought, while the disks already on it keep working and can still be resized.
|
|
82
|
-
*/
|
|
13
|
+
/** List disk types on sale */
|
|
83
14
|
get: operations["list-disk-types"];
|
|
84
15
|
put?: never;
|
|
85
16
|
post?: never;
|
|
@@ -96,10 +27,7 @@ export interface paths {
|
|
|
96
27
|
path?: never;
|
|
97
28
|
cookie?: never;
|
|
98
29
|
};
|
|
99
|
-
/**
|
|
100
|
-
* Get a disk type
|
|
101
|
-
* @description Retrieve capacity and performance constraints for an existing disk, including system disk types and types withdrawn from sale.
|
|
102
|
-
*/
|
|
30
|
+
/** Get a disk type */
|
|
103
31
|
get: operations["get-disk-type"];
|
|
104
32
|
put?: never;
|
|
105
33
|
post?: never;
|
|
@@ -116,15 +44,12 @@ export interface paths {
|
|
|
116
44
|
path?: never;
|
|
117
45
|
cookie?: never;
|
|
118
46
|
};
|
|
119
|
-
/**
|
|
120
|
-
* List disks
|
|
121
|
-
* @description Lists disks in the current project. Use resource-usages to inspect consumers and pending reservations.
|
|
122
|
-
*/
|
|
47
|
+
/** List disks in the current project */
|
|
123
48
|
get: operations["list-disks"];
|
|
124
49
|
put?: never;
|
|
125
50
|
/**
|
|
126
|
-
* Create a disk
|
|
127
|
-
* @description
|
|
51
|
+
* Create a disk purchase
|
|
52
|
+
* @description Checks Fleet capacity, creates the local disk intent, and places a Billing order. Reuse the same idempotency key after an uncertain response. Billing resolves contract pricing, sellable quota, grants, payment challenges, and expiry.
|
|
128
53
|
*/
|
|
129
54
|
post: operations["create-disk"];
|
|
130
55
|
delete?: never;
|
|
@@ -140,135 +65,21 @@ export interface paths {
|
|
|
140
65
|
path?: never;
|
|
141
66
|
cookie?: never;
|
|
142
67
|
};
|
|
143
|
-
/**
|
|
144
|
-
* Retrieve a disk
|
|
145
|
-
* @description Returns the disk and its observed state. Read its attachments for consumers, device names and pending attachment operations.
|
|
146
|
-
*/
|
|
68
|
+
/** Get a disk */
|
|
147
69
|
get: operations["get-disk"];
|
|
148
70
|
put?: never;
|
|
149
71
|
post?: never;
|
|
150
72
|
/**
|
|
151
73
|
* Delete a disk
|
|
152
|
-
* @description Deletion is rejected while the disk
|
|
74
|
+
* @description Deletion is asynchronous and is rejected while the disk has a live attachment or another live resource claim. Billing ends resource-bound subscriptions only after Cinder confirms deletion.
|
|
153
75
|
*/
|
|
154
76
|
delete: operations["delete-disk"];
|
|
155
77
|
options?: never;
|
|
156
78
|
head?: never;
|
|
157
|
-
/**
|
|
158
|
-
* Rename a disk
|
|
159
|
-
* @description Changes the name only. Use the resize endpoint for capacity; type and availability zone are immutable.
|
|
160
|
-
*/
|
|
79
|
+
/** Rename a disk */
|
|
161
80
|
patch: operations["rename-disk"];
|
|
162
81
|
trace?: never;
|
|
163
82
|
};
|
|
164
|
-
"/api/v1/disks/{diskId}/resize": {
|
|
165
|
-
parameters: {
|
|
166
|
-
query?: never;
|
|
167
|
-
header?: never;
|
|
168
|
-
path?: never;
|
|
169
|
-
cookie?: never;
|
|
170
|
-
};
|
|
171
|
-
get?: never;
|
|
172
|
-
put?: never;
|
|
173
|
-
/**
|
|
174
|
-
* Resize a disk
|
|
175
|
-
* @description Creates a Billing order, including for metered pricing. The price must belong to the resource’s Billing Plan; applicable contract pricing is resolved by Billing. Technical capacity is checked before sellable quota is reserved. Provisioning continues automatically after payment; do not submit a new purchase after paying. Reuse the original idempotency key after an uncertain response.
|
|
176
|
-
*/
|
|
177
|
-
post: operations["resize-disk"];
|
|
178
|
-
delete?: never;
|
|
179
|
-
options?: never;
|
|
180
|
-
head?: never;
|
|
181
|
-
patch?: never;
|
|
182
|
-
trace?: never;
|
|
183
|
-
};
|
|
184
|
-
"/api/v1/disks/{diskId}/revert": {
|
|
185
|
-
parameters: {
|
|
186
|
-
query?: never;
|
|
187
|
-
header?: never;
|
|
188
|
-
path?: never;
|
|
189
|
-
cookie?: never;
|
|
190
|
-
};
|
|
191
|
-
get?: never;
|
|
192
|
-
put?: never;
|
|
193
|
-
/**
|
|
194
|
-
* Revert to a snapshot
|
|
195
|
-
* @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.**
|
|
196
|
-
*
|
|
197
|
-
* 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.
|
|
198
|
-
*
|
|
199
|
-
* The revert is not complete when this endpoint returns; poll the retrieve endpoint.
|
|
200
|
-
*/
|
|
201
|
-
post: operations["revert-disk"];
|
|
202
|
-
delete?: never;
|
|
203
|
-
options?: never;
|
|
204
|
-
head?: never;
|
|
205
|
-
patch?: never;
|
|
206
|
-
trace?: never;
|
|
207
|
-
};
|
|
208
|
-
"/api/v1/operation-logs": {
|
|
209
|
-
parameters: {
|
|
210
|
-
query?: never;
|
|
211
|
-
header?: never;
|
|
212
|
-
path?: never;
|
|
213
|
-
cookie?: never;
|
|
214
|
-
};
|
|
215
|
-
/**
|
|
216
|
-
* List the operation log of the project
|
|
217
|
-
* @description Records every write operation in the project: who performed it, when, on what, and whether it succeeded. Read operations are not recorded.
|
|
218
|
-
*
|
|
219
|
-
* **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.
|
|
220
|
-
*
|
|
221
|
-
* Fields such as passwords are replaced with a placeholder as the record is written and never appear in `payload`.
|
|
222
|
-
*/
|
|
223
|
-
get: operations["list-operation-logs"];
|
|
224
|
-
put?: never;
|
|
225
|
-
post?: never;
|
|
226
|
-
delete?: never;
|
|
227
|
-
options?: never;
|
|
228
|
-
head?: never;
|
|
229
|
-
patch?: never;
|
|
230
|
-
trace?: never;
|
|
231
|
-
};
|
|
232
|
-
"/api/v1/snapshots": {
|
|
233
|
-
parameters: {
|
|
234
|
-
query?: never;
|
|
235
|
-
header?: never;
|
|
236
|
-
path?: never;
|
|
237
|
-
cookie?: never;
|
|
238
|
-
};
|
|
239
|
-
/** List snapshots */
|
|
240
|
-
get: operations["list-snapshots"];
|
|
241
|
-
put?: never;
|
|
242
|
-
/**
|
|
243
|
-
* Create a snapshot
|
|
244
|
-
* @description Creates a Billing order, including for metered pricing. The price must belong to the resource’s Billing Plan; applicable contract pricing is resolved by Billing. Technical capacity is checked before sellable quota is reserved. Provisioning continues automatically after payment; do not submit a new purchase after paying. Reuse the original idempotency key after an uncertain response.
|
|
245
|
-
*/
|
|
246
|
-
post: operations["create-snapshot"];
|
|
247
|
-
delete?: never;
|
|
248
|
-
options?: never;
|
|
249
|
-
head?: never;
|
|
250
|
-
patch?: never;
|
|
251
|
-
trace?: never;
|
|
252
|
-
};
|
|
253
|
-
"/api/v1/snapshots/{snapshotId}": {
|
|
254
|
-
parameters: {
|
|
255
|
-
query?: never;
|
|
256
|
-
header?: never;
|
|
257
|
-
path?: never;
|
|
258
|
-
cookie?: never;
|
|
259
|
-
};
|
|
260
|
-
/** Retrieve a snapshot */
|
|
261
|
-
get: operations["get-snapshot"];
|
|
262
|
-
put?: never;
|
|
263
|
-
post?: never;
|
|
264
|
-
/** Delete a snapshot */
|
|
265
|
-
delete: operations["delete-snapshot"];
|
|
266
|
-
options?: never;
|
|
267
|
-
head?: never;
|
|
268
|
-
/** Rename a snapshot */
|
|
269
|
-
patch: operations["rename-snapshot"];
|
|
270
|
-
trace?: never;
|
|
271
|
-
};
|
|
272
83
|
"/api/v1/resource-usages": {
|
|
273
84
|
parameters: {
|
|
274
85
|
query?: never;
|
|
@@ -278,7 +89,7 @@ export interface paths {
|
|
|
278
89
|
};
|
|
279
90
|
/**
|
|
280
91
|
* List resource usages
|
|
281
|
-
* @description Lists direct consumers
|
|
92
|
+
* @description Lists direct consumers and pending reservations for a resource readable in the current project.
|
|
282
93
|
*/
|
|
283
94
|
get: operations["list-resource-usages"];
|
|
284
95
|
put?: never;
|
|
@@ -296,7 +107,7 @@ export interface paths {
|
|
|
296
107
|
path?: never;
|
|
297
108
|
cookie?: never;
|
|
298
109
|
};
|
|
299
|
-
/** Get resource usage */
|
|
110
|
+
/** Get a resource usage */
|
|
300
111
|
get: operations["get-resource-usage"];
|
|
301
112
|
put?: never;
|
|
302
113
|
post?: never;
|
|
@@ -313,7 +124,7 @@ export interface paths {
|
|
|
313
124
|
path?: never;
|
|
314
125
|
cookie?: never;
|
|
315
126
|
};
|
|
316
|
-
/** Get resource reclamation */
|
|
127
|
+
/** Get resource reclamation state */
|
|
317
128
|
get: operations["get-resource-reclamation"];
|
|
318
129
|
put?: never;
|
|
319
130
|
post?: never;
|
|
@@ -333,7 +144,7 @@ export interface paths {
|
|
|
333
144
|
get?: never;
|
|
334
145
|
/**
|
|
335
146
|
* Set resource idle policy
|
|
336
|
-
* @description
|
|
147
|
+
* @description Enabling automatic cleanup starts a fresh retention interval after the last live claim is released. Existing claims and pending operations always block reclamation.
|
|
337
148
|
*/
|
|
338
149
|
put: operations["set-resource-idle-policy"];
|
|
339
150
|
post?: never;
|
|
@@ -343,17 +154,14 @@ export interface paths {
|
|
|
343
154
|
patch?: never;
|
|
344
155
|
trace?: never;
|
|
345
156
|
};
|
|
346
|
-
"/api/v1/disks/{
|
|
157
|
+
"/api/v1/disks/{diskId}/attachments": {
|
|
347
158
|
parameters: {
|
|
348
159
|
query?: never;
|
|
349
160
|
header?: never;
|
|
350
161
|
path?: never;
|
|
351
162
|
cookie?: never;
|
|
352
163
|
};
|
|
353
|
-
/**
|
|
354
|
-
* List disk attachments
|
|
355
|
-
* @description Actual attachment state, including operations whose provider outcome is unknown. Use usage_id to locate the corresponding blocking claim.
|
|
356
|
-
*/
|
|
164
|
+
/** List disk attachments */
|
|
357
165
|
get: operations["list-disk-attachments"];
|
|
358
166
|
put?: never;
|
|
359
167
|
post?: never;
|
|
@@ -370,7 +178,7 @@ export interface paths {
|
|
|
370
178
|
path?: never;
|
|
371
179
|
cookie?: never;
|
|
372
180
|
};
|
|
373
|
-
/** Get attachment */
|
|
181
|
+
/** Get a disk attachment */
|
|
374
182
|
get: operations["get-attachment"];
|
|
375
183
|
put?: never;
|
|
376
184
|
post?: never;
|
|
@@ -384,275 +192,89 @@ export interface paths {
|
|
|
384
192
|
export type webhooks = Record<string, never>;
|
|
385
193
|
export interface components {
|
|
386
194
|
schemas: {
|
|
387
|
-
|
|
388
|
-
code?: string;
|
|
389
|
-
message: string;
|
|
390
|
-
/**
|
|
391
|
-
* @description What a given `code` carries alongside the message. The keys depend on the code,
|
|
392
|
-
* and a client that does not recognise one ignores it.
|
|
393
|
-
*/
|
|
394
|
-
meta?: {
|
|
395
|
-
[key: string]: unknown;
|
|
396
|
-
};
|
|
397
|
-
/** Format: int64 */
|
|
398
|
-
status: number;
|
|
399
|
-
};
|
|
400
|
-
BackupResource: {
|
|
401
|
-
/** Format: uuid */
|
|
402
|
-
availability_zone_id: string;
|
|
403
|
-
/** Format: date-time */
|
|
404
|
-
created_at: string;
|
|
195
|
+
Disk: {
|
|
405
196
|
/** Format: uuid */
|
|
406
197
|
id: string;
|
|
407
198
|
name: string;
|
|
408
199
|
/** Format: uuid */
|
|
409
200
|
region_id: string;
|
|
410
|
-
/**
|
|
411
|
-
* Format: int64
|
|
412
|
-
* @description Capacity of the source disk when the backup was created. A restored disk cannot be smaller than this
|
|
413
|
-
*/
|
|
414
|
-
size_gb: number;
|
|
415
|
-
/**
|
|
416
|
-
* Format: uuid
|
|
417
|
-
* @description The disk this backup was taken from. The backup remains usable after that disk is deleted
|
|
418
|
-
*/
|
|
419
|
-
source_disk_id: string;
|
|
420
|
-
/** @enum {string} */
|
|
421
|
-
status: "provisioning" | "available" | "restoring" | "deleting" | "error";
|
|
422
|
-
subscription_item_ids?: string[];
|
|
423
|
-
};
|
|
424
|
-
BackupListResponseBody: {
|
|
425
|
-
items: components["schemas"]["BackupResource"][];
|
|
426
|
-
/** Format: int64 */
|
|
427
|
-
page: number;
|
|
428
|
-
/** Format: int64 */
|
|
429
|
-
page_size: number;
|
|
430
|
-
/** Format: int64 */
|
|
431
|
-
total_count?: number;
|
|
432
|
-
};
|
|
433
|
-
CreateBackupRequestBody: {
|
|
434
|
-
/** Format: uuid */
|
|
435
|
-
disk_id: string;
|
|
436
|
-
name: string;
|
|
437
|
-
order: components["schemas"]["OrderOptions"];
|
|
438
|
-
price: components["schemas"]["CatalogReference"];
|
|
439
|
-
};
|
|
440
|
-
RenameBackupRequestBody: {
|
|
441
|
-
name: string;
|
|
442
|
-
};
|
|
443
|
-
RestoreBackupRequestBody: {
|
|
444
|
-
/**
|
|
445
|
-
* Format: uuid
|
|
446
|
-
* @description May differ from the availability zone of the source disk, but must be in the same region. It has to be on sale — restoring creates a new disk, so a withdrawn type is rejected here as well
|
|
447
|
-
*/
|
|
448
|
-
disk_type_id: string;
|
|
449
|
-
name: string;
|
|
450
|
-
/**
|
|
451
|
-
* Format: int64
|
|
452
|
-
* @description Matches the size of the backup when omitted. When given, it must not be smaller than the backup
|
|
453
|
-
*/
|
|
454
|
-
size_gb?: number;
|
|
455
|
-
order: components["schemas"]["OrderOptions"];
|
|
456
|
-
price: components["schemas"]["CatalogReference"];
|
|
457
|
-
};
|
|
458
|
-
DiskResource: {
|
|
459
201
|
/** Format: uuid */
|
|
460
202
|
availability_zone_id: string;
|
|
461
|
-
/** Format: date-time */
|
|
462
|
-
created_at: string;
|
|
463
203
|
/** Format: uuid */
|
|
464
204
|
disk_type_id: string;
|
|
465
|
-
/** Format: uuid */
|
|
466
|
-
id: string;
|
|
467
|
-
name: string;
|
|
468
|
-
/** Format: uuid */
|
|
469
|
-
region_id: string;
|
|
470
205
|
/** Format: int64 */
|
|
471
206
|
size_gb: number;
|
|
472
|
-
/**
|
|
473
|
-
* Format: int64
|
|
474
|
-
* @description IOPS this disk is allowed. Null when its type is not rate-limited.
|
|
475
|
-
*
|
|
476
|
-
* Computed from the disk's own capacity, so it grows when the disk is grown — but see the
|
|
477
|
-
* note on the resize endpoint: growing a disk that is attached is refused, precisely because
|
|
478
|
-
* the new figure would not take effect until it was attached again.
|
|
479
|
-
*/
|
|
480
|
-
iops: number | null;
|
|
481
|
-
/**
|
|
482
|
-
* Format: int64
|
|
483
|
-
* @description Throughput this disk is allowed, in bytes per second. Null when its type is not rate-limited
|
|
484
|
-
*/
|
|
485
|
-
throughput_bytes_per_sec: number | null;
|
|
486
207
|
/** @enum {string} */
|
|
487
208
|
status: "provisioning" | "available" | "attaching" | "in_use" | "detaching" | "resizing" | "reverting" | "restoring" | "releasing" | "deleting" | "error";
|
|
488
|
-
|
|
209
|
+
/** Format: date-time */
|
|
210
|
+
created_at: string;
|
|
211
|
+
/** Format: date-time */
|
|
212
|
+
updated_at: string;
|
|
213
|
+
/** Format: date-time */
|
|
214
|
+
deleted_at?: string | null;
|
|
489
215
|
};
|
|
490
|
-
|
|
491
|
-
|
|
492
|
-
|
|
216
|
+
DiskList: {
|
|
217
|
+
items: components["schemas"]["Disk"][];
|
|
218
|
+
pagination: components["schemas"]["OffsetPagination"];
|
|
219
|
+
};
|
|
220
|
+
DiskType: {
|
|
493
221
|
/** Format: uuid */
|
|
494
222
|
id: string;
|
|
495
|
-
|
|
496
|
-
|
|
497
|
-
* @description IOPS a disk of `min_size_gb` gets. Null when this type is not rate-limited.
|
|
498
|
-
*
|
|
499
|
-
* Performance grows with capacity, so this and `iops_at_max_size` are the two ends of the
|
|
500
|
-
* range. The exact figure for the size actually bought appears on the disk itself once it
|
|
501
|
-
* exists.
|
|
502
|
-
*/
|
|
503
|
-
iops_at_min_size: number | null;
|
|
504
|
-
/**
|
|
505
|
-
* Format: int64
|
|
506
|
-
* @description IOPS a disk of `max_size_gb` gets. Null when this type is not rate-limited
|
|
507
|
-
*/
|
|
508
|
-
iops_at_max_size: number | null;
|
|
509
|
-
/** Format: int64 */
|
|
510
|
-
max_size_gb: number;
|
|
223
|
+
lookup_key: string;
|
|
224
|
+
name: string;
|
|
511
225
|
/** @enum {string} */
|
|
512
226
|
media: "ssd" | "hdd" | "nvme";
|
|
513
|
-
/** Format: int64 */
|
|
514
|
-
min_size_gb: number;
|
|
515
|
-
name: string;
|
|
516
227
|
/** Format: uuid */
|
|
517
228
|
region_id: string;
|
|
229
|
+
/** Format: uuid */
|
|
230
|
+
availability_zone_id: string;
|
|
231
|
+
/** Format: int64 */
|
|
232
|
+
min_size_gb: number;
|
|
233
|
+
/** Format: int64 */
|
|
234
|
+
max_size_gb: number;
|
|
518
235
|
/** Format: int64 */
|
|
519
236
|
step_gb: number;
|
|
520
|
-
|
|
521
|
-
|
|
522
|
-
* @description Throughput a disk of `min_size_gb` gets, in **bytes per second**. Null when this type is
|
|
523
|
-
* not rate-limited.
|
|
524
|
-
*
|
|
525
|
-
* Bytes rather than MiB so the number needs no rounding on the way out; divide by 1048576
|
|
526
|
-
* for MiB/s at the point of display.
|
|
527
|
-
*/
|
|
528
|
-
throughput_at_min_size: number | null;
|
|
529
|
-
/**
|
|
530
|
-
* Format: int64
|
|
531
|
-
* @description Throughput a disk of `max_size_gb` gets, in bytes per second. Null when this type is not rate-limited
|
|
532
|
-
*/
|
|
533
|
-
throughput_at_max_size: number | null;
|
|
534
|
-
/**
|
|
535
|
-
* Format: uuid
|
|
536
|
-
* @description The Billing Plan for this type. Read its available prices from Billing; resource capacity and sellable quota are evaluated when placing the order.
|
|
537
|
-
*/
|
|
237
|
+
for_system: boolean;
|
|
238
|
+
/** Format: uuid */
|
|
538
239
|
billing_plan_id: string;
|
|
539
240
|
};
|
|
540
|
-
|
|
541
|
-
items: components["schemas"]["
|
|
542
|
-
|
|
543
|
-
page: number;
|
|
544
|
-
/** Format: int64 */
|
|
545
|
-
page_size: number;
|
|
546
|
-
/** Format: int64 */
|
|
547
|
-
total_count?: number;
|
|
241
|
+
DiskTypeList: {
|
|
242
|
+
items: components["schemas"]["DiskType"][];
|
|
243
|
+
pagination: components["schemas"]["OffsetPagination"];
|
|
548
244
|
};
|
|
549
|
-
|
|
550
|
-
|
|
551
|
-
/** Format:
|
|
552
|
-
|
|
553
|
-
|
|
554
|
-
page_size: number;
|
|
555
|
-
/** Format: int64 */
|
|
556
|
-
total_count?: number;
|
|
245
|
+
/** @description Specify exactly one of id or lookup_key. A lookup key is scoped to the product of the resource service. */
|
|
246
|
+
CatalogReference: {
|
|
247
|
+
/** Format: uuid */
|
|
248
|
+
id?: string;
|
|
249
|
+
lookup_key?: string;
|
|
557
250
|
};
|
|
558
|
-
|
|
559
|
-
/**
|
|
560
|
-
* Format: uuid
|
|
561
|
-
* @description A disk type currently on sale. A withdrawn one is rejected even though its identifier still resolves
|
|
562
|
-
*/
|
|
251
|
+
CreateDiskRequest: {
|
|
252
|
+
/** Format: uuid */
|
|
563
253
|
disk_type_id: string;
|
|
564
254
|
name: string;
|
|
565
255
|
/** Format: int64 */
|
|
566
256
|
size_gb: number;
|
|
567
|
-
/**
|
|
568
|
-
* Format: uuid
|
|
569
|
-
* @description Restore from this snapshot. When given, the capacity need only be no smaller than the snapshot
|
|
570
|
-
*/
|
|
571
|
-
snapshot_id?: string;
|
|
572
|
-
order: components["schemas"]["OrderOptions"];
|
|
573
257
|
price: components["schemas"]["CatalogReference"];
|
|
574
|
-
};
|
|
575
|
-
RenameDiskRequestBody: {
|
|
576
|
-
name: string;
|
|
577
|
-
};
|
|
578
|
-
ResizeDiskRequestBody: {
|
|
579
|
-
/**
|
|
580
|
-
* Format: int64
|
|
581
|
-
* @description Must be larger than the current capacity
|
|
582
|
-
*/
|
|
583
|
-
size_gb: number;
|
|
584
258
|
order: components["schemas"]["OrderOptions"];
|
|
585
|
-
price: components["schemas"]["CatalogReference"];
|
|
586
259
|
};
|
|
587
|
-
|
|
588
|
-
|
|
589
|
-
* Format: uuid
|
|
590
|
-
* @description Must be the most recent snapshot of the disk
|
|
591
|
-
*/
|
|
592
|
-
snapshot_id: string;
|
|
260
|
+
RenameRequest: {
|
|
261
|
+
name: string;
|
|
593
262
|
};
|
|
594
|
-
|
|
595
|
-
|
|
596
|
-
|
|
597
|
-
/** @description The user who initiated the operation. Empty when the platform performed it */
|
|
598
|
-
actor: string | null;
|
|
263
|
+
Error: {
|
|
264
|
+
code?: string;
|
|
265
|
+
message: string;
|
|
599
266
|
/**
|
|
600
|
-
* @description
|
|
601
|
-
*
|
|
602
|
-
* Null on entries recorded before this field existed, and on entries performed by the platform. An empty string means the account had no name recorded.
|
|
267
|
+
* @description What a given `code` carries alongside the message. The keys depend on the code,
|
|
268
|
+
* and a client that does not recognise one ignores it.
|
|
603
269
|
*/
|
|
604
|
-
|
|
605
|
-
/** @description True when the operation was performed by the platform */
|
|
606
|
-
by_platform: boolean;
|
|
607
|
-
/** Format: date-time */
|
|
608
|
-
created_at: string;
|
|
609
|
-
/** @description Brief reason for the failure */
|
|
610
|
-
failure: string | null;
|
|
611
|
-
/** Format: uuid */
|
|
612
|
-
id: string;
|
|
613
|
-
/** @description Path and query parameters of the request. Fields such as passwords are redacted */
|
|
614
|
-
payload: {
|
|
270
|
+
meta?: {
|
|
615
271
|
[key: string]: unknown;
|
|
616
272
|
};
|
|
617
|
-
/** Format: uuid */
|
|
618
|
-
region_id: string | null;
|
|
619
|
-
/** @description Empty for create operations: the id of the new resource is in the response, not in the request path */
|
|
620
|
-
subject_id: string;
|
|
621
|
-
subject_type: string;
|
|
622
|
-
succeeded: boolean;
|
|
623
|
-
};
|
|
624
|
-
OperationLogListResponseBody: {
|
|
625
|
-
items: components["schemas"]["OperationLogResource"][];
|
|
626
273
|
/** Format: int64 */
|
|
627
|
-
|
|
628
|
-
/** Format: int64 */
|
|
629
|
-
page_size: number;
|
|
630
|
-
/** Format: int64 */
|
|
631
|
-
total_count?: number;
|
|
632
|
-
};
|
|
633
|
-
SnapshotResource: {
|
|
634
|
-
/** Format: uuid */
|
|
635
|
-
availability_zone_id: string;
|
|
636
|
-
/** Format: date-time */
|
|
637
|
-
created_at: string;
|
|
638
|
-
/** Format: uuid */
|
|
639
|
-
disk_id: string;
|
|
640
|
-
/** Format: uuid */
|
|
641
|
-
id: string;
|
|
642
|
-
name: string;
|
|
643
|
-
/** Format: uuid */
|
|
644
|
-
region_id: string;
|
|
645
|
-
/**
|
|
646
|
-
* Format: int64
|
|
647
|
-
* @description Capacity of the source disk when the snapshot was created. A disk restored from it cannot be smaller
|
|
648
|
-
*/
|
|
649
|
-
size_gb: number;
|
|
650
|
-
/** @enum {string} */
|
|
651
|
-
status: "provisioning" | "available" | "restoring" | "deleting" | "error";
|
|
652
|
-
subscription_item_ids?: string[];
|
|
274
|
+
status: number;
|
|
653
275
|
};
|
|
654
|
-
|
|
655
|
-
|
|
276
|
+
/** @description Pagination metadata for stable numbered pages. total_count is returned only when the operation can determine it without an unbounded scan. */
|
|
277
|
+
OffsetPagination: {
|
|
656
278
|
/** Format: int64 */
|
|
657
279
|
page: number;
|
|
658
280
|
/** Format: int64 */
|
|
@@ -660,15 +282,10 @@ export interface components {
|
|
|
660
282
|
/** Format: int64 */
|
|
661
283
|
total_count?: number;
|
|
662
284
|
};
|
|
663
|
-
|
|
664
|
-
|
|
665
|
-
|
|
666
|
-
|
|
667
|
-
order: components["schemas"]["OrderOptions"];
|
|
668
|
-
price: components["schemas"]["CatalogReference"];
|
|
669
|
-
};
|
|
670
|
-
RenameSnapshotRequestBody: {
|
|
671
|
-
name: string;
|
|
285
|
+
/** @description Requested funding split. This does not select a card or payment provider; complete payment through Billing. */
|
|
286
|
+
PaymentPlan: {
|
|
287
|
+
balance_amount: string;
|
|
288
|
+
provider_amount: string;
|
|
672
289
|
};
|
|
673
290
|
/** @description Reuse the same key for retries of the same purchase. Reusing it with a different request fails. Billing selects contract pricing, applies eligible grants and promotions, and owns payment challenges and expiry. */
|
|
674
291
|
OrderOptions: {
|
|
@@ -677,12 +294,6 @@ export interface components {
|
|
|
677
294
|
expected_amount?: string;
|
|
678
295
|
redemption_code?: string;
|
|
679
296
|
};
|
|
680
|
-
/** @description Specify exactly one of id or lookup_key. A lookup key is scoped to the product of the resource service. */
|
|
681
|
-
CatalogReference: {
|
|
682
|
-
/** Format: uuid */
|
|
683
|
-
id?: string;
|
|
684
|
-
lookup_key?: string;
|
|
685
|
-
};
|
|
686
297
|
/**
|
|
687
298
|
* @description A billable order has been created. Read it from the billing API to find out what is
|
|
688
299
|
* owed and whether payment is still required.
|
|
@@ -702,578 +313,128 @@ export interface components {
|
|
|
702
313
|
*/
|
|
703
314
|
order_id: string;
|
|
704
315
|
};
|
|
705
|
-
/** @description
|
|
706
|
-
|
|
707
|
-
|
|
708
|
-
|
|
709
|
-
/** Format: uuid */
|
|
710
|
-
|
|
711
|
-
resource: components["schemas"]["ResourceReference"];
|
|
712
|
-
consumer: components["schemas"]["ResourceReference"];
|
|
713
|
-
purpose: string;
|
|
714
|
-
/** @enum {string} */
|
|
715
|
-
state: "reserved" | "active" | "releasing" | "released";
|
|
716
|
-
/** Format: int64 */
|
|
717
|
-
generation: number;
|
|
718
|
-
/** Format: uuid */
|
|
719
|
-
operation_id: string;
|
|
720
|
-
/** Format: date-time */
|
|
721
|
-
created_at: string;
|
|
722
|
-
/** Format: date-time */
|
|
723
|
-
updated_at: string;
|
|
724
|
-
/** Format: date-time */
|
|
725
|
-
released_at?: string;
|
|
726
|
-
};
|
|
727
|
-
ResourceUsageList: {
|
|
728
|
-
items: components["schemas"]["ResourceUsage"][];
|
|
729
|
-
/** Format: int64 */
|
|
730
|
-
page: number;
|
|
731
|
-
/** Format: int64 */
|
|
732
|
-
page_size: number;
|
|
733
|
-
/** Format: int64 */
|
|
734
|
-
total_count?: number;
|
|
735
|
-
};
|
|
736
|
-
/** @description Automatic reclamation is disabled by default. When enabled, retention starts after the last live claim is confirmed released. Traffic, IO and consumer heartbeats do not affect eligibility. */
|
|
737
|
-
IdlePolicy: {
|
|
738
|
-
/** @default false */
|
|
739
|
-
enabled: boolean;
|
|
740
|
-
/** Format: int64 */
|
|
741
|
-
retention_seconds: number;
|
|
742
|
-
};
|
|
743
|
-
ReclamationState: {
|
|
744
|
-
resource: components["schemas"]["ResourceReference"];
|
|
745
|
-
policy: components["schemas"]["IdlePolicy"];
|
|
746
|
-
/** Format: int64 */
|
|
747
|
-
active_usage_count: number;
|
|
748
|
-
/** Format: date-time */
|
|
749
|
-
unreferenced_at?: string;
|
|
750
|
-
/** Format: date-time */
|
|
751
|
-
eligible_at?: string;
|
|
752
|
-
/** @enum {string} */
|
|
753
|
-
status: "retained" | "in_use" | "idle" | "reclaiming" | "deleted";
|
|
754
|
-
blocked_reasons: string[];
|
|
755
|
-
};
|
|
756
|
-
Attachment: {
|
|
757
|
-
/** Format: uuid */
|
|
758
|
-
id: string;
|
|
759
|
-
/** Format: uuid */
|
|
760
|
-
usage_id: string;
|
|
761
|
-
resource: components["schemas"]["ResourceReference"];
|
|
762
|
-
consumer: components["schemas"]["ResourceReference"];
|
|
763
|
-
/** @enum {string} */
|
|
764
|
-
state: "reserved" | "attaching" | "attached" | "detaching" | "detached" | "unknown";
|
|
765
|
-
/** Format: int64 */
|
|
766
|
-
generation: number;
|
|
767
|
-
device?: string;
|
|
768
|
-
read_only: boolean;
|
|
769
|
-
/** Format: date-time */
|
|
770
|
-
created_at: string;
|
|
771
|
-
/** Format: date-time */
|
|
772
|
-
updated_at: string;
|
|
773
|
-
};
|
|
774
|
-
AttachmentList: {
|
|
775
|
-
items: components["schemas"]["Attachment"][];
|
|
776
|
-
/** Format: int64 */
|
|
777
|
-
page: number;
|
|
778
|
-
/** Format: int64 */
|
|
779
|
-
page_size: number;
|
|
780
|
-
/** Format: int64 */
|
|
781
|
-
total_count?: number;
|
|
782
|
-
};
|
|
783
|
-
/** @description Requested funding split. This does not select a card or payment provider; complete payment through Billing. */
|
|
784
|
-
PaymentPlan: {
|
|
785
|
-
balance_amount: string;
|
|
786
|
-
provider_amount: string;
|
|
787
|
-
};
|
|
788
|
-
/** @description A resource identified within its owning service. The project is taken from the containing usage or request. */
|
|
789
|
-
ResourceReference: {
|
|
790
|
-
service: string;
|
|
791
|
-
type: string;
|
|
792
|
-
/** Format: uuid */
|
|
793
|
-
id: string;
|
|
794
|
-
};
|
|
795
|
-
};
|
|
796
|
-
responses: never;
|
|
797
|
-
parameters: never;
|
|
798
|
-
requestBodies: never;
|
|
799
|
-
headers: never;
|
|
800
|
-
pathItems: never;
|
|
801
|
-
}
|
|
802
|
-
export type $defs = Record<string, never>;
|
|
803
|
-
export interface operations {
|
|
804
|
-
"list-backups": {
|
|
805
|
-
parameters: {
|
|
806
|
-
query?: {
|
|
807
|
-
/** @description Return only the backups of this disk */
|
|
808
|
-
disk_id?: string;
|
|
809
|
-
page?: number;
|
|
810
|
-
page_size?: number;
|
|
811
|
-
};
|
|
812
|
-
header?: never;
|
|
813
|
-
path?: never;
|
|
814
|
-
cookie?: never;
|
|
815
|
-
};
|
|
816
|
-
requestBody?: never;
|
|
817
|
-
responses: {
|
|
818
|
-
/** @description OK */
|
|
819
|
-
200: {
|
|
820
|
-
headers: {
|
|
821
|
-
[name: string]: unknown;
|
|
822
|
-
};
|
|
823
|
-
content: {
|
|
824
|
-
"application/json": components["schemas"]["BackupListResponseBody"];
|
|
825
|
-
};
|
|
826
|
-
};
|
|
827
|
-
/** @description Error */
|
|
828
|
-
default: {
|
|
829
|
-
headers: {
|
|
830
|
-
[name: string]: unknown;
|
|
831
|
-
};
|
|
832
|
-
content: {
|
|
833
|
-
"application/json": components["schemas"]["Error"];
|
|
834
|
-
};
|
|
835
|
-
};
|
|
836
|
-
};
|
|
837
|
-
};
|
|
838
|
-
"create-backup": {
|
|
839
|
-
parameters: {
|
|
840
|
-
query?: never;
|
|
841
|
-
header?: never;
|
|
842
|
-
path?: never;
|
|
843
|
-
cookie?: never;
|
|
844
|
-
};
|
|
845
|
-
requestBody: {
|
|
846
|
-
content: {
|
|
847
|
-
"application/json": components["schemas"]["CreateBackupRequestBody"];
|
|
848
|
-
};
|
|
849
|
-
};
|
|
850
|
-
responses: {
|
|
851
|
-
/** @description Accepted */
|
|
852
|
-
202: {
|
|
853
|
-
headers: {
|
|
854
|
-
[name: string]: unknown;
|
|
855
|
-
};
|
|
856
|
-
content: {
|
|
857
|
-
"application/json": components["schemas"]["PlacedOrder"];
|
|
858
|
-
};
|
|
859
|
-
};
|
|
860
|
-
/** @description Error */
|
|
861
|
-
default: {
|
|
862
|
-
headers: {
|
|
863
|
-
[name: string]: unknown;
|
|
864
|
-
};
|
|
865
|
-
content: {
|
|
866
|
-
"application/json": components["schemas"]["Error"];
|
|
867
|
-
};
|
|
868
|
-
};
|
|
869
|
-
};
|
|
870
|
-
};
|
|
871
|
-
"get-backup": {
|
|
872
|
-
parameters: {
|
|
873
|
-
query?: never;
|
|
874
|
-
header?: never;
|
|
875
|
-
path: {
|
|
876
|
-
backupId: string;
|
|
877
|
-
};
|
|
878
|
-
cookie?: never;
|
|
879
|
-
};
|
|
880
|
-
requestBody?: never;
|
|
881
|
-
responses: {
|
|
882
|
-
/** @description OK */
|
|
883
|
-
200: {
|
|
884
|
-
headers: {
|
|
885
|
-
[name: string]: unknown;
|
|
886
|
-
};
|
|
887
|
-
content: {
|
|
888
|
-
"application/json": components["schemas"]["BackupResource"];
|
|
889
|
-
};
|
|
890
|
-
};
|
|
891
|
-
/** @description Error */
|
|
892
|
-
default: {
|
|
893
|
-
headers: {
|
|
894
|
-
[name: string]: unknown;
|
|
895
|
-
};
|
|
896
|
-
content: {
|
|
897
|
-
"application/json": components["schemas"]["Error"];
|
|
898
|
-
};
|
|
899
|
-
};
|
|
900
|
-
};
|
|
901
|
-
};
|
|
902
|
-
"delete-backup": {
|
|
903
|
-
parameters: {
|
|
904
|
-
query?: never;
|
|
905
|
-
header?: never;
|
|
906
|
-
path: {
|
|
907
|
-
backupId: string;
|
|
908
|
-
};
|
|
909
|
-
cookie?: never;
|
|
910
|
-
};
|
|
911
|
-
requestBody?: never;
|
|
912
|
-
responses: {
|
|
913
|
-
/** @description No Content */
|
|
914
|
-
204: {
|
|
915
|
-
headers: {
|
|
916
|
-
[name: string]: unknown;
|
|
917
|
-
};
|
|
918
|
-
content?: never;
|
|
919
|
-
};
|
|
920
|
-
/** @description Error */
|
|
921
|
-
default: {
|
|
922
|
-
headers: {
|
|
923
|
-
[name: string]: unknown;
|
|
924
|
-
};
|
|
925
|
-
content: {
|
|
926
|
-
"application/json": components["schemas"]["Error"];
|
|
927
|
-
};
|
|
928
|
-
};
|
|
929
|
-
};
|
|
930
|
-
};
|
|
931
|
-
"rename-backup": {
|
|
932
|
-
parameters: {
|
|
933
|
-
query?: never;
|
|
934
|
-
header?: never;
|
|
935
|
-
path: {
|
|
936
|
-
backupId: string;
|
|
937
|
-
};
|
|
938
|
-
cookie?: never;
|
|
939
|
-
};
|
|
940
|
-
requestBody: {
|
|
941
|
-
content: {
|
|
942
|
-
"application/json": components["schemas"]["RenameBackupRequestBody"];
|
|
943
|
-
};
|
|
944
|
-
};
|
|
945
|
-
responses: {
|
|
946
|
-
/** @description OK */
|
|
947
|
-
200: {
|
|
948
|
-
headers: {
|
|
949
|
-
[name: string]: unknown;
|
|
950
|
-
};
|
|
951
|
-
content: {
|
|
952
|
-
"application/json": components["schemas"]["BackupResource"];
|
|
953
|
-
};
|
|
954
|
-
};
|
|
955
|
-
/** @description Error */
|
|
956
|
-
default: {
|
|
957
|
-
headers: {
|
|
958
|
-
[name: string]: unknown;
|
|
959
|
-
};
|
|
960
|
-
content: {
|
|
961
|
-
"application/json": components["schemas"]["Error"];
|
|
962
|
-
};
|
|
963
|
-
};
|
|
964
|
-
};
|
|
965
|
-
};
|
|
966
|
-
"restore-backup": {
|
|
967
|
-
parameters: {
|
|
968
|
-
query?: never;
|
|
969
|
-
header?: never;
|
|
970
|
-
path: {
|
|
971
|
-
backupId: string;
|
|
972
|
-
};
|
|
973
|
-
cookie?: never;
|
|
974
|
-
};
|
|
975
|
-
requestBody: {
|
|
976
|
-
content: {
|
|
977
|
-
"application/json": components["schemas"]["RestoreBackupRequestBody"];
|
|
978
|
-
};
|
|
979
|
-
};
|
|
980
|
-
responses: {
|
|
981
|
-
/** @description Accepted */
|
|
982
|
-
202: {
|
|
983
|
-
headers: {
|
|
984
|
-
[name: string]: unknown;
|
|
985
|
-
};
|
|
986
|
-
content: {
|
|
987
|
-
"application/json": components["schemas"]["PlacedOrder"];
|
|
988
|
-
};
|
|
989
|
-
};
|
|
990
|
-
/** @description Error */
|
|
991
|
-
default: {
|
|
992
|
-
headers: {
|
|
993
|
-
[name: string]: unknown;
|
|
994
|
-
};
|
|
995
|
-
content: {
|
|
996
|
-
"application/json": components["schemas"]["Error"];
|
|
997
|
-
};
|
|
998
|
-
};
|
|
999
|
-
};
|
|
1000
|
-
};
|
|
1001
|
-
"list-disk-types": {
|
|
1002
|
-
parameters: {
|
|
1003
|
-
query: {
|
|
1004
|
-
region_id: string;
|
|
1005
|
-
page?: number;
|
|
1006
|
-
page_size?: number;
|
|
1007
|
-
};
|
|
1008
|
-
header?: never;
|
|
1009
|
-
path?: never;
|
|
1010
|
-
cookie?: never;
|
|
1011
|
-
};
|
|
1012
|
-
requestBody?: never;
|
|
1013
|
-
responses: {
|
|
1014
|
-
/** @description OK */
|
|
1015
|
-
200: {
|
|
1016
|
-
headers: {
|
|
1017
|
-
[name: string]: unknown;
|
|
1018
|
-
};
|
|
1019
|
-
content: {
|
|
1020
|
-
"application/json": components["schemas"]["DiskTypeListResponseBody"];
|
|
1021
|
-
};
|
|
1022
|
-
};
|
|
1023
|
-
/** @description Error */
|
|
1024
|
-
default: {
|
|
1025
|
-
headers: {
|
|
1026
|
-
[name: string]: unknown;
|
|
1027
|
-
};
|
|
1028
|
-
content: {
|
|
1029
|
-
"application/json": components["schemas"]["Error"];
|
|
1030
|
-
};
|
|
1031
|
-
};
|
|
1032
|
-
};
|
|
1033
|
-
};
|
|
1034
|
-
"get-disk-type": {
|
|
1035
|
-
parameters: {
|
|
1036
|
-
query?: never;
|
|
1037
|
-
header?: never;
|
|
1038
|
-
path: {
|
|
1039
|
-
diskTypeId: string;
|
|
1040
|
-
};
|
|
1041
|
-
cookie?: never;
|
|
1042
|
-
};
|
|
1043
|
-
requestBody?: never;
|
|
1044
|
-
responses: {
|
|
1045
|
-
/** @description OK */
|
|
1046
|
-
200: {
|
|
1047
|
-
headers: {
|
|
1048
|
-
[name: string]: unknown;
|
|
1049
|
-
};
|
|
1050
|
-
content: {
|
|
1051
|
-
"application/json": components["schemas"]["DiskTypeResource"];
|
|
1052
|
-
};
|
|
1053
|
-
};
|
|
1054
|
-
/** @description Error */
|
|
1055
|
-
default: {
|
|
1056
|
-
headers: {
|
|
1057
|
-
[name: string]: unknown;
|
|
1058
|
-
};
|
|
1059
|
-
content: {
|
|
1060
|
-
"application/json": components["schemas"]["Error"];
|
|
1061
|
-
};
|
|
1062
|
-
};
|
|
1063
|
-
};
|
|
1064
|
-
};
|
|
1065
|
-
"list-disks": {
|
|
1066
|
-
parameters: {
|
|
1067
|
-
query?: {
|
|
1068
|
-
region_id?: string;
|
|
1069
|
-
/** @description Supplied together with `region_id` to filter attachable disks */
|
|
1070
|
-
availability_zone_id?: string;
|
|
1071
|
-
page?: number;
|
|
1072
|
-
page_size?: number;
|
|
1073
|
-
};
|
|
1074
|
-
header?: never;
|
|
1075
|
-
path?: never;
|
|
1076
|
-
cookie?: never;
|
|
1077
|
-
};
|
|
1078
|
-
requestBody?: never;
|
|
1079
|
-
responses: {
|
|
1080
|
-
/** @description OK */
|
|
1081
|
-
200: {
|
|
1082
|
-
headers: {
|
|
1083
|
-
[name: string]: unknown;
|
|
1084
|
-
};
|
|
1085
|
-
content: {
|
|
1086
|
-
"application/json": components["schemas"]["DiskListResponseBody"];
|
|
1087
|
-
};
|
|
1088
|
-
};
|
|
1089
|
-
/** @description Error */
|
|
1090
|
-
default: {
|
|
1091
|
-
headers: {
|
|
1092
|
-
[name: string]: unknown;
|
|
1093
|
-
};
|
|
1094
|
-
content: {
|
|
1095
|
-
"application/json": components["schemas"]["Error"];
|
|
1096
|
-
};
|
|
1097
|
-
};
|
|
1098
|
-
};
|
|
1099
|
-
};
|
|
1100
|
-
"create-disk": {
|
|
1101
|
-
parameters: {
|
|
1102
|
-
query?: never;
|
|
1103
|
-
header?: never;
|
|
1104
|
-
path?: never;
|
|
1105
|
-
cookie?: never;
|
|
1106
|
-
};
|
|
1107
|
-
requestBody: {
|
|
1108
|
-
content: {
|
|
1109
|
-
"application/json": components["schemas"]["CreateDiskRequestBody"];
|
|
1110
|
-
};
|
|
1111
|
-
};
|
|
1112
|
-
responses: {
|
|
1113
|
-
/** @description Accepted */
|
|
1114
|
-
202: {
|
|
1115
|
-
headers: {
|
|
1116
|
-
[name: string]: unknown;
|
|
1117
|
-
};
|
|
1118
|
-
content: {
|
|
1119
|
-
"application/json": components["schemas"]["PlacedOrder"];
|
|
1120
|
-
};
|
|
1121
|
-
};
|
|
1122
|
-
/** @description Error */
|
|
1123
|
-
default: {
|
|
1124
|
-
headers: {
|
|
1125
|
-
[name: string]: unknown;
|
|
1126
|
-
};
|
|
1127
|
-
content: {
|
|
1128
|
-
"application/json": components["schemas"]["Error"];
|
|
1129
|
-
};
|
|
1130
|
-
};
|
|
1131
|
-
};
|
|
1132
|
-
};
|
|
1133
|
-
"get-disk": {
|
|
1134
|
-
parameters: {
|
|
1135
|
-
query?: never;
|
|
1136
|
-
header?: never;
|
|
1137
|
-
path: {
|
|
1138
|
-
diskId: string;
|
|
1139
|
-
};
|
|
1140
|
-
cookie?: never;
|
|
1141
|
-
};
|
|
1142
|
-
requestBody?: never;
|
|
1143
|
-
responses: {
|
|
1144
|
-
/** @description OK */
|
|
1145
|
-
200: {
|
|
1146
|
-
headers: {
|
|
1147
|
-
[name: string]: unknown;
|
|
1148
|
-
};
|
|
1149
|
-
content: {
|
|
1150
|
-
"application/json": components["schemas"]["DiskResource"];
|
|
1151
|
-
};
|
|
1152
|
-
};
|
|
1153
|
-
/** @description Error */
|
|
1154
|
-
default: {
|
|
1155
|
-
headers: {
|
|
1156
|
-
[name: string]: unknown;
|
|
1157
|
-
};
|
|
1158
|
-
content: {
|
|
1159
|
-
"application/json": components["schemas"]["Error"];
|
|
1160
|
-
};
|
|
1161
|
-
};
|
|
1162
|
-
};
|
|
1163
|
-
};
|
|
1164
|
-
"delete-disk": {
|
|
1165
|
-
parameters: {
|
|
1166
|
-
query?: never;
|
|
1167
|
-
header?: never;
|
|
1168
|
-
path: {
|
|
1169
|
-
diskId: string;
|
|
1170
|
-
};
|
|
1171
|
-
cookie?: never;
|
|
316
|
+
/** @description A resource identified within its owning service. The project is taken from the containing usage or request. */
|
|
317
|
+
ResourceReference: {
|
|
318
|
+
service: string;
|
|
319
|
+
type: string;
|
|
320
|
+
/** Format: uuid */
|
|
321
|
+
id: string;
|
|
1172
322
|
};
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
/**
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
1182
|
-
/** @
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
|
|
1187
|
-
|
|
1188
|
-
|
|
1189
|
-
|
|
1190
|
-
|
|
323
|
+
/** @description An authoritative claim held by the resource owner. Reserved, active and releasing claims all prevent idle reclamation. Stopped consumers retain their claims. Released claims remain readable. */
|
|
324
|
+
ResourceUsage: {
|
|
325
|
+
/** Format: uuid */
|
|
326
|
+
id: string;
|
|
327
|
+
/** Format: uuid */
|
|
328
|
+
project_id: string;
|
|
329
|
+
resource: components["schemas"]["ResourceReference"];
|
|
330
|
+
consumer: components["schemas"]["ResourceReference"];
|
|
331
|
+
purpose: string;
|
|
332
|
+
/** @enum {string} */
|
|
333
|
+
state: "reserved" | "active" | "releasing" | "released";
|
|
334
|
+
/** Format: int64 */
|
|
335
|
+
generation: number;
|
|
336
|
+
/** Format: uuid */
|
|
337
|
+
operation_id: string;
|
|
338
|
+
/** Format: date-time */
|
|
339
|
+
created_at: string;
|
|
340
|
+
/** Format: date-time */
|
|
341
|
+
updated_at: string;
|
|
342
|
+
/** Format: date-time */
|
|
343
|
+
released_at?: string;
|
|
1191
344
|
};
|
|
1192
|
-
|
|
1193
|
-
|
|
1194
|
-
|
|
1195
|
-
query?: never;
|
|
1196
|
-
header?: never;
|
|
1197
|
-
path: {
|
|
1198
|
-
diskId: string;
|
|
1199
|
-
};
|
|
1200
|
-
cookie?: never;
|
|
345
|
+
ResourceUsageList: {
|
|
346
|
+
items: components["schemas"]["ResourceUsage"][];
|
|
347
|
+
pagination: components["schemas"]["OffsetPagination"];
|
|
1201
348
|
};
|
|
1202
|
-
|
|
1203
|
-
|
|
1204
|
-
|
|
1205
|
-
|
|
349
|
+
/** @description Automatic reclamation is disabled by default. When enabled, retention starts after the last live claim is confirmed released. Traffic, IO and consumer heartbeats do not affect eligibility. */
|
|
350
|
+
IdlePolicy: {
|
|
351
|
+
/** @default false */
|
|
352
|
+
enabled: boolean;
|
|
353
|
+
/** Format: int64 */
|
|
354
|
+
retention_seconds: number;
|
|
1206
355
|
};
|
|
1207
|
-
|
|
1208
|
-
|
|
1209
|
-
|
|
1210
|
-
|
|
1211
|
-
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
|
|
1216
|
-
}
|
|
1217
|
-
|
|
1218
|
-
|
|
1219
|
-
headers: {
|
|
1220
|
-
[name: string]: unknown;
|
|
1221
|
-
};
|
|
1222
|
-
content: {
|
|
1223
|
-
"application/json": components["schemas"]["Error"];
|
|
1224
|
-
};
|
|
1225
|
-
};
|
|
356
|
+
ReclamationState: {
|
|
357
|
+
resource: components["schemas"]["ResourceReference"];
|
|
358
|
+
policy: components["schemas"]["IdlePolicy"];
|
|
359
|
+
/** Format: int64 */
|
|
360
|
+
active_usage_count: number;
|
|
361
|
+
/** Format: date-time */
|
|
362
|
+
unreferenced_at?: string;
|
|
363
|
+
/** Format: date-time */
|
|
364
|
+
eligible_at?: string;
|
|
365
|
+
/** @enum {string} */
|
|
366
|
+
status: "retained" | "in_use" | "idle" | "reclaiming" | "deleted";
|
|
367
|
+
blocked_reasons: string[];
|
|
1226
368
|
};
|
|
1227
|
-
|
|
1228
|
-
|
|
1229
|
-
|
|
1230
|
-
|
|
1231
|
-
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
}
|
|
1235
|
-
|
|
369
|
+
Attachment: {
|
|
370
|
+
/** Format: uuid */
|
|
371
|
+
id: string;
|
|
372
|
+
/** Format: uuid */
|
|
373
|
+
usage_id: string;
|
|
374
|
+
resource: components["schemas"]["ResourceReference"];
|
|
375
|
+
consumer: components["schemas"]["ResourceReference"];
|
|
376
|
+
/** @enum {string} */
|
|
377
|
+
state: "reserved" | "attaching" | "attached" | "detaching" | "detached" | "unknown";
|
|
378
|
+
/** Format: int64 */
|
|
379
|
+
generation: number;
|
|
380
|
+
device?: string;
|
|
381
|
+
read_only: boolean;
|
|
382
|
+
/** Format: date-time */
|
|
383
|
+
created_at: string;
|
|
384
|
+
/** Format: date-time */
|
|
385
|
+
updated_at: string;
|
|
1236
386
|
};
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
|
|
1240
|
-
};
|
|
387
|
+
AttachmentList: {
|
|
388
|
+
items: components["schemas"]["Attachment"][];
|
|
389
|
+
pagination: components["schemas"]["OffsetPagination"];
|
|
1241
390
|
};
|
|
1242
|
-
|
|
1243
|
-
|
|
1244
|
-
|
|
1245
|
-
|
|
1246
|
-
|
|
1247
|
-
|
|
1248
|
-
content: {
|
|
1249
|
-
"application/json": components["schemas"]["PlacedOrder"];
|
|
1250
|
-
};
|
|
1251
|
-
};
|
|
1252
|
-
/** @description Error */
|
|
1253
|
-
default: {
|
|
1254
|
-
headers: {
|
|
1255
|
-
[name: string]: unknown;
|
|
1256
|
-
};
|
|
1257
|
-
content: {
|
|
1258
|
-
"application/json": components["schemas"]["Error"];
|
|
1259
|
-
};
|
|
391
|
+
};
|
|
392
|
+
responses: {
|
|
393
|
+
/** @description Error */
|
|
394
|
+
Error: {
|
|
395
|
+
headers: {
|
|
396
|
+
[name: string]: unknown;
|
|
1260
397
|
};
|
|
1261
|
-
|
|
398
|
+
content: {
|
|
399
|
+
"application/json": components["schemas"]["Error"];
|
|
400
|
+
};
|
|
401
|
+
};
|
|
402
|
+
};
|
|
403
|
+
parameters: {
|
|
404
|
+
DiskTypeID: string;
|
|
405
|
+
DiskID: string;
|
|
406
|
+
UsageID: string;
|
|
407
|
+
AttachmentID: string;
|
|
408
|
+
RegionID: string;
|
|
409
|
+
RegionIDOptional: string;
|
|
410
|
+
AvailabilityZoneIDOptional: string;
|
|
411
|
+
ResourceType: "disk";
|
|
412
|
+
ResourceID: string;
|
|
413
|
+
ResourceTypePath: "disk";
|
|
414
|
+
ResourceIDPath: string;
|
|
415
|
+
IncludeReleased: boolean;
|
|
416
|
+
IncludeDetached: boolean;
|
|
417
|
+
Page: number;
|
|
418
|
+
PageSize: number;
|
|
1262
419
|
};
|
|
1263
|
-
|
|
420
|
+
requestBodies: never;
|
|
421
|
+
headers: never;
|
|
422
|
+
pathItems: never;
|
|
423
|
+
}
|
|
424
|
+
export type $defs = Record<string, never>;
|
|
425
|
+
export interface operations {
|
|
426
|
+
"list-disk-types": {
|
|
1264
427
|
parameters: {
|
|
1265
|
-
query
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
428
|
+
query: {
|
|
429
|
+
region_id: components["parameters"]["RegionID"];
|
|
430
|
+
page?: components["parameters"]["Page"];
|
|
431
|
+
page_size?: components["parameters"]["PageSize"];
|
|
1269
432
|
};
|
|
433
|
+
header?: never;
|
|
434
|
+
path?: never;
|
|
1270
435
|
cookie?: never;
|
|
1271
436
|
};
|
|
1272
|
-
requestBody
|
|
1273
|
-
content: {
|
|
1274
|
-
"application/json": components["schemas"]["RevertDiskRequestBody"];
|
|
1275
|
-
};
|
|
1276
|
-
};
|
|
437
|
+
requestBody?: never;
|
|
1277
438
|
responses: {
|
|
1278
439
|
/** @description OK */
|
|
1279
440
|
200: {
|
|
@@ -1281,30 +442,19 @@ export interface operations {
|
|
|
1281
442
|
[name: string]: unknown;
|
|
1282
443
|
};
|
|
1283
444
|
content: {
|
|
1284
|
-
"application/json": components["schemas"]["
|
|
1285
|
-
};
|
|
1286
|
-
};
|
|
1287
|
-
/** @description Error */
|
|
1288
|
-
default: {
|
|
1289
|
-
headers: {
|
|
1290
|
-
[name: string]: unknown;
|
|
1291
|
-
};
|
|
1292
|
-
content: {
|
|
1293
|
-
"application/json": components["schemas"]["Error"];
|
|
445
|
+
"application/json": components["schemas"]["DiskTypeList"];
|
|
1294
446
|
};
|
|
1295
447
|
};
|
|
448
|
+
default: components["responses"]["Error"];
|
|
1296
449
|
};
|
|
1297
450
|
};
|
|
1298
|
-
"
|
|
451
|
+
"get-disk-type": {
|
|
1299
452
|
parameters: {
|
|
1300
|
-
query?:
|
|
1301
|
-
/** @description Return a single kind of operation; the value matches the operation id of the endpoint */
|
|
1302
|
-
action?: string;
|
|
1303
|
-
page?: number;
|
|
1304
|
-
page_size?: number;
|
|
1305
|
-
};
|
|
453
|
+
query?: never;
|
|
1306
454
|
header?: never;
|
|
1307
|
-
path
|
|
455
|
+
path: {
|
|
456
|
+
diskTypeId: components["parameters"]["DiskTypeID"];
|
|
457
|
+
};
|
|
1308
458
|
cookie?: never;
|
|
1309
459
|
};
|
|
1310
460
|
requestBody?: never;
|
|
@@ -1315,27 +465,19 @@ export interface operations {
|
|
|
1315
465
|
[name: string]: unknown;
|
|
1316
466
|
};
|
|
1317
467
|
content: {
|
|
1318
|
-
"application/json": components["schemas"]["
|
|
1319
|
-
};
|
|
1320
|
-
};
|
|
1321
|
-
/** @description Error */
|
|
1322
|
-
default: {
|
|
1323
|
-
headers: {
|
|
1324
|
-
[name: string]: unknown;
|
|
1325
|
-
};
|
|
1326
|
-
content: {
|
|
1327
|
-
"application/json": components["schemas"]["Error"];
|
|
468
|
+
"application/json": components["schemas"]["DiskType"];
|
|
1328
469
|
};
|
|
1329
470
|
};
|
|
471
|
+
default: components["responses"]["Error"];
|
|
1330
472
|
};
|
|
1331
473
|
};
|
|
1332
|
-
"list-
|
|
474
|
+
"list-disks": {
|
|
1333
475
|
parameters: {
|
|
1334
476
|
query?: {
|
|
1335
|
-
|
|
1336
|
-
|
|
1337
|
-
page?:
|
|
1338
|
-
page_size?:
|
|
477
|
+
region_id?: components["parameters"]["RegionIDOptional"];
|
|
478
|
+
availability_zone_id?: components["parameters"]["AvailabilityZoneIDOptional"];
|
|
479
|
+
page?: components["parameters"]["Page"];
|
|
480
|
+
page_size?: components["parameters"]["PageSize"];
|
|
1339
481
|
};
|
|
1340
482
|
header?: never;
|
|
1341
483
|
path?: never;
|
|
@@ -1349,21 +491,13 @@ export interface operations {
|
|
|
1349
491
|
[name: string]: unknown;
|
|
1350
492
|
};
|
|
1351
493
|
content: {
|
|
1352
|
-
"application/json": components["schemas"]["
|
|
1353
|
-
};
|
|
1354
|
-
};
|
|
1355
|
-
/** @description Error */
|
|
1356
|
-
default: {
|
|
1357
|
-
headers: {
|
|
1358
|
-
[name: string]: unknown;
|
|
1359
|
-
};
|
|
1360
|
-
content: {
|
|
1361
|
-
"application/json": components["schemas"]["Error"];
|
|
494
|
+
"application/json": components["schemas"]["DiskList"];
|
|
1362
495
|
};
|
|
1363
496
|
};
|
|
497
|
+
default: components["responses"]["Error"];
|
|
1364
498
|
};
|
|
1365
499
|
};
|
|
1366
|
-
"create-
|
|
500
|
+
"create-disk": {
|
|
1367
501
|
parameters: {
|
|
1368
502
|
query?: never;
|
|
1369
503
|
header?: never;
|
|
@@ -1372,11 +506,11 @@ export interface operations {
|
|
|
1372
506
|
};
|
|
1373
507
|
requestBody: {
|
|
1374
508
|
content: {
|
|
1375
|
-
"application/json": components["schemas"]["
|
|
509
|
+
"application/json": components["schemas"]["CreateDiskRequest"];
|
|
1376
510
|
};
|
|
1377
511
|
};
|
|
1378
512
|
responses: {
|
|
1379
|
-
/** @description
|
|
513
|
+
/** @description Order placed */
|
|
1380
514
|
202: {
|
|
1381
515
|
headers: {
|
|
1382
516
|
[name: string]: unknown;
|
|
@@ -1385,23 +519,15 @@ export interface operations {
|
|
|
1385
519
|
"application/json": components["schemas"]["PlacedOrder"];
|
|
1386
520
|
};
|
|
1387
521
|
};
|
|
1388
|
-
|
|
1389
|
-
default: {
|
|
1390
|
-
headers: {
|
|
1391
|
-
[name: string]: unknown;
|
|
1392
|
-
};
|
|
1393
|
-
content: {
|
|
1394
|
-
"application/json": components["schemas"]["Error"];
|
|
1395
|
-
};
|
|
1396
|
-
};
|
|
522
|
+
default: components["responses"]["Error"];
|
|
1397
523
|
};
|
|
1398
524
|
};
|
|
1399
|
-
"get-
|
|
525
|
+
"get-disk": {
|
|
1400
526
|
parameters: {
|
|
1401
527
|
query?: never;
|
|
1402
528
|
header?: never;
|
|
1403
529
|
path: {
|
|
1404
|
-
|
|
530
|
+
diskId: components["parameters"]["DiskID"];
|
|
1405
531
|
};
|
|
1406
532
|
cookie?: never;
|
|
1407
533
|
};
|
|
@@ -1413,61 +539,47 @@ export interface operations {
|
|
|
1413
539
|
[name: string]: unknown;
|
|
1414
540
|
};
|
|
1415
541
|
content: {
|
|
1416
|
-
"application/json": components["schemas"]["
|
|
1417
|
-
};
|
|
1418
|
-
};
|
|
1419
|
-
/** @description Error */
|
|
1420
|
-
default: {
|
|
1421
|
-
headers: {
|
|
1422
|
-
[name: string]: unknown;
|
|
1423
|
-
};
|
|
1424
|
-
content: {
|
|
1425
|
-
"application/json": components["schemas"]["Error"];
|
|
542
|
+
"application/json": components["schemas"]["Disk"];
|
|
1426
543
|
};
|
|
1427
544
|
};
|
|
545
|
+
default: components["responses"]["Error"];
|
|
1428
546
|
};
|
|
1429
547
|
};
|
|
1430
|
-
"delete-
|
|
548
|
+
"delete-disk": {
|
|
1431
549
|
parameters: {
|
|
1432
|
-
query
|
|
550
|
+
query: {
|
|
551
|
+
idempotency_key: string;
|
|
552
|
+
};
|
|
1433
553
|
header?: never;
|
|
1434
554
|
path: {
|
|
1435
|
-
|
|
555
|
+
diskId: components["parameters"]["DiskID"];
|
|
1436
556
|
};
|
|
1437
557
|
cookie?: never;
|
|
1438
558
|
};
|
|
1439
559
|
requestBody?: never;
|
|
1440
560
|
responses: {
|
|
1441
|
-
/** @description
|
|
561
|
+
/** @description Accepted */
|
|
1442
562
|
204: {
|
|
1443
563
|
headers: {
|
|
1444
564
|
[name: string]: unknown;
|
|
1445
565
|
};
|
|
1446
566
|
content?: never;
|
|
1447
567
|
};
|
|
1448
|
-
|
|
1449
|
-
default: {
|
|
1450
|
-
headers: {
|
|
1451
|
-
[name: string]: unknown;
|
|
1452
|
-
};
|
|
1453
|
-
content: {
|
|
1454
|
-
"application/json": components["schemas"]["Error"];
|
|
1455
|
-
};
|
|
1456
|
-
};
|
|
568
|
+
default: components["responses"]["Error"];
|
|
1457
569
|
};
|
|
1458
570
|
};
|
|
1459
|
-
"rename-
|
|
571
|
+
"rename-disk": {
|
|
1460
572
|
parameters: {
|
|
1461
573
|
query?: never;
|
|
1462
574
|
header?: never;
|
|
1463
575
|
path: {
|
|
1464
|
-
|
|
576
|
+
diskId: components["parameters"]["DiskID"];
|
|
1465
577
|
};
|
|
1466
578
|
cookie?: never;
|
|
1467
579
|
};
|
|
1468
580
|
requestBody: {
|
|
1469
581
|
content: {
|
|
1470
|
-
"application/json": components["schemas"]["
|
|
582
|
+
"application/json": components["schemas"]["RenameRequest"];
|
|
1471
583
|
};
|
|
1472
584
|
};
|
|
1473
585
|
responses: {
|
|
@@ -1477,28 +589,20 @@ export interface operations {
|
|
|
1477
589
|
[name: string]: unknown;
|
|
1478
590
|
};
|
|
1479
591
|
content: {
|
|
1480
|
-
"application/json": components["schemas"]["
|
|
1481
|
-
};
|
|
1482
|
-
};
|
|
1483
|
-
/** @description Error */
|
|
1484
|
-
default: {
|
|
1485
|
-
headers: {
|
|
1486
|
-
[name: string]: unknown;
|
|
1487
|
-
};
|
|
1488
|
-
content: {
|
|
1489
|
-
"application/json": components["schemas"]["Error"];
|
|
592
|
+
"application/json": components["schemas"]["Disk"];
|
|
1490
593
|
};
|
|
1491
594
|
};
|
|
595
|
+
default: components["responses"]["Error"];
|
|
1492
596
|
};
|
|
1493
597
|
};
|
|
1494
598
|
"list-resource-usages": {
|
|
1495
599
|
parameters: {
|
|
1496
600
|
query: {
|
|
1497
|
-
resource_type:
|
|
1498
|
-
resource_id:
|
|
1499
|
-
include_released?:
|
|
1500
|
-
page?:
|
|
1501
|
-
page_size?:
|
|
601
|
+
resource_type: components["parameters"]["ResourceType"];
|
|
602
|
+
resource_id: components["parameters"]["ResourceID"];
|
|
603
|
+
include_released?: components["parameters"]["IncludeReleased"];
|
|
604
|
+
page?: components["parameters"]["Page"];
|
|
605
|
+
page_size?: components["parameters"]["PageSize"];
|
|
1502
606
|
};
|
|
1503
607
|
header?: never;
|
|
1504
608
|
path?: never;
|
|
@@ -1515,15 +619,7 @@ export interface operations {
|
|
|
1515
619
|
"application/json": components["schemas"]["ResourceUsageList"];
|
|
1516
620
|
};
|
|
1517
621
|
};
|
|
1518
|
-
|
|
1519
|
-
default: {
|
|
1520
|
-
headers: {
|
|
1521
|
-
[name: string]: unknown;
|
|
1522
|
-
};
|
|
1523
|
-
content: {
|
|
1524
|
-
"application/json": components["schemas"]["Error"];
|
|
1525
|
-
};
|
|
1526
|
-
};
|
|
622
|
+
default: components["responses"]["Error"];
|
|
1527
623
|
};
|
|
1528
624
|
};
|
|
1529
625
|
"get-resource-usage": {
|
|
@@ -1531,7 +627,7 @@ export interface operations {
|
|
|
1531
627
|
query?: never;
|
|
1532
628
|
header?: never;
|
|
1533
629
|
path: {
|
|
1534
|
-
usageId:
|
|
630
|
+
usageId: components["parameters"]["UsageID"];
|
|
1535
631
|
};
|
|
1536
632
|
cookie?: never;
|
|
1537
633
|
};
|
|
@@ -1546,15 +642,7 @@ export interface operations {
|
|
|
1546
642
|
"application/json": components["schemas"]["ResourceUsage"];
|
|
1547
643
|
};
|
|
1548
644
|
};
|
|
1549
|
-
|
|
1550
|
-
default: {
|
|
1551
|
-
headers: {
|
|
1552
|
-
[name: string]: unknown;
|
|
1553
|
-
};
|
|
1554
|
-
content: {
|
|
1555
|
-
"application/json": components["schemas"]["Error"];
|
|
1556
|
-
};
|
|
1557
|
-
};
|
|
645
|
+
default: components["responses"]["Error"];
|
|
1558
646
|
};
|
|
1559
647
|
};
|
|
1560
648
|
"get-resource-reclamation": {
|
|
@@ -1562,8 +650,8 @@ export interface operations {
|
|
|
1562
650
|
query?: never;
|
|
1563
651
|
header?: never;
|
|
1564
652
|
path: {
|
|
1565
|
-
resourceType:
|
|
1566
|
-
resourceId:
|
|
653
|
+
resourceType: components["parameters"]["ResourceTypePath"];
|
|
654
|
+
resourceId: components["parameters"]["ResourceIDPath"];
|
|
1567
655
|
};
|
|
1568
656
|
cookie?: never;
|
|
1569
657
|
};
|
|
@@ -1578,15 +666,7 @@ export interface operations {
|
|
|
1578
666
|
"application/json": components["schemas"]["ReclamationState"];
|
|
1579
667
|
};
|
|
1580
668
|
};
|
|
1581
|
-
|
|
1582
|
-
default: {
|
|
1583
|
-
headers: {
|
|
1584
|
-
[name: string]: unknown;
|
|
1585
|
-
};
|
|
1586
|
-
content: {
|
|
1587
|
-
"application/json": components["schemas"]["Error"];
|
|
1588
|
-
};
|
|
1589
|
-
};
|
|
669
|
+
default: components["responses"]["Error"];
|
|
1590
670
|
};
|
|
1591
671
|
};
|
|
1592
672
|
"set-resource-idle-policy": {
|
|
@@ -1594,8 +674,8 @@ export interface operations {
|
|
|
1594
674
|
query?: never;
|
|
1595
675
|
header?: never;
|
|
1596
676
|
path: {
|
|
1597
|
-
resourceType:
|
|
1598
|
-
resourceId:
|
|
677
|
+
resourceType: components["parameters"]["ResourceTypePath"];
|
|
678
|
+
resourceId: components["parameters"]["ResourceIDPath"];
|
|
1599
679
|
};
|
|
1600
680
|
cookie?: never;
|
|
1601
681
|
};
|
|
@@ -1614,27 +694,19 @@ export interface operations {
|
|
|
1614
694
|
"application/json": components["schemas"]["ReclamationState"];
|
|
1615
695
|
};
|
|
1616
696
|
};
|
|
1617
|
-
|
|
1618
|
-
default: {
|
|
1619
|
-
headers: {
|
|
1620
|
-
[name: string]: unknown;
|
|
1621
|
-
};
|
|
1622
|
-
content: {
|
|
1623
|
-
"application/json": components["schemas"]["Error"];
|
|
1624
|
-
};
|
|
1625
|
-
};
|
|
697
|
+
default: components["responses"]["Error"];
|
|
1626
698
|
};
|
|
1627
699
|
};
|
|
1628
700
|
"list-disk-attachments": {
|
|
1629
701
|
parameters: {
|
|
1630
702
|
query?: {
|
|
1631
|
-
|
|
1632
|
-
|
|
1633
|
-
|
|
703
|
+
include_detached?: components["parameters"]["IncludeDetached"];
|
|
704
|
+
page?: components["parameters"]["Page"];
|
|
705
|
+
page_size?: components["parameters"]["PageSize"];
|
|
1634
706
|
};
|
|
1635
707
|
header?: never;
|
|
1636
708
|
path: {
|
|
1637
|
-
|
|
709
|
+
diskId: components["parameters"]["DiskID"];
|
|
1638
710
|
};
|
|
1639
711
|
cookie?: never;
|
|
1640
712
|
};
|
|
@@ -1649,15 +721,7 @@ export interface operations {
|
|
|
1649
721
|
"application/json": components["schemas"]["AttachmentList"];
|
|
1650
722
|
};
|
|
1651
723
|
};
|
|
1652
|
-
|
|
1653
|
-
default: {
|
|
1654
|
-
headers: {
|
|
1655
|
-
[name: string]: unknown;
|
|
1656
|
-
};
|
|
1657
|
-
content: {
|
|
1658
|
-
"application/json": components["schemas"]["Error"];
|
|
1659
|
-
};
|
|
1660
|
-
};
|
|
724
|
+
default: components["responses"]["Error"];
|
|
1661
725
|
};
|
|
1662
726
|
};
|
|
1663
727
|
"get-attachment": {
|
|
@@ -1665,7 +729,7 @@ export interface operations {
|
|
|
1665
729
|
query?: never;
|
|
1666
730
|
header?: never;
|
|
1667
731
|
path: {
|
|
1668
|
-
attachmentId:
|
|
732
|
+
attachmentId: components["parameters"]["AttachmentID"];
|
|
1669
733
|
};
|
|
1670
734
|
cookie?: never;
|
|
1671
735
|
};
|
|
@@ -1680,15 +744,7 @@ export interface operations {
|
|
|
1680
744
|
"application/json": components["schemas"]["Attachment"];
|
|
1681
745
|
};
|
|
1682
746
|
};
|
|
1683
|
-
|
|
1684
|
-
default: {
|
|
1685
|
-
headers: {
|
|
1686
|
-
[name: string]: unknown;
|
|
1687
|
-
};
|
|
1688
|
-
content: {
|
|
1689
|
-
"application/json": components["schemas"]["Error"];
|
|
1690
|
-
};
|
|
1691
|
-
};
|
|
747
|
+
default: components["responses"]["Error"];
|
|
1692
748
|
};
|
|
1693
749
|
};
|
|
1694
750
|
}
|