@zgeoff/imp-client 0.4.0 → 0.5.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/index.d.ts +1266 -29
- package/dist/index.js +3 -2
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -8,8 +8,10 @@ declare const ApiCallSchema: z.ZodObject<{
|
|
|
8
8
|
actor: z.ZodEnum<{
|
|
9
9
|
dashboard: "dashboard";
|
|
10
10
|
ssh: "ssh";
|
|
11
|
+
tailnet: "tailnet";
|
|
11
12
|
token: "token";
|
|
12
13
|
}>;
|
|
14
|
+
actorName: z.ZodOptional<z.ZodString>;
|
|
13
15
|
imp: z.ZodOptional<z.ZodString>;
|
|
14
16
|
outcome: z.ZodString;
|
|
15
17
|
durationMs: z.ZodInt;
|
|
@@ -22,6 +24,7 @@ declare const CheckpointSchema: z.ZodObject<{
|
|
|
22
24
|
label: z.ZodOptional<z.ZodString>;
|
|
23
25
|
createdAt: z.ZodDate;
|
|
24
26
|
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
27
|
+
diskMib: z.ZodInt;
|
|
25
28
|
}, z.core.$strip>;
|
|
26
29
|
type Checkpoint = z.infer<typeof CheckpointSchema>;
|
|
27
30
|
//#endregion
|
|
@@ -51,6 +54,14 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
51
54
|
}>;
|
|
52
55
|
vcpus: z.ZodInt;
|
|
53
56
|
memoryMib: z.ZodInt;
|
|
57
|
+
diskMib: z.ZodInt;
|
|
58
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
59
|
+
exclusiveBytes: z.ZodInt;
|
|
60
|
+
sharedBytes: z.ZodInt;
|
|
61
|
+
measuredAt: z.ZodDate;
|
|
62
|
+
isPartial: z.ZodBoolean;
|
|
63
|
+
isUpperBound: z.ZodBoolean;
|
|
64
|
+
}, z.core.$strip>>;
|
|
54
65
|
ip: z.ZodIPv4;
|
|
55
66
|
slot: z.ZodInt;
|
|
56
67
|
port: z.ZodInt;
|
|
@@ -82,6 +93,7 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
82
93
|
failed: "failed";
|
|
83
94
|
held: "held";
|
|
84
95
|
repaired: "repaired";
|
|
96
|
+
resized: "resized";
|
|
85
97
|
restored: "restored";
|
|
86
98
|
slept: "slept";
|
|
87
99
|
stopped: "stopped";
|
|
@@ -100,6 +112,14 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
100
112
|
}>;
|
|
101
113
|
vcpus: z.ZodInt;
|
|
102
114
|
memoryMib: z.ZodInt;
|
|
115
|
+
diskMib: z.ZodInt;
|
|
116
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
117
|
+
exclusiveBytes: z.ZodInt;
|
|
118
|
+
sharedBytes: z.ZodInt;
|
|
119
|
+
measuredAt: z.ZodDate;
|
|
120
|
+
isPartial: z.ZodBoolean;
|
|
121
|
+
isUpperBound: z.ZodBoolean;
|
|
122
|
+
}, z.core.$strip>>;
|
|
103
123
|
ip: z.ZodIPv4;
|
|
104
124
|
slot: z.ZodInt;
|
|
105
125
|
port: z.ZodInt;
|
|
@@ -144,6 +164,14 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
144
164
|
}>;
|
|
145
165
|
vcpus: z.ZodInt;
|
|
146
166
|
memoryMib: z.ZodInt;
|
|
167
|
+
diskMib: z.ZodInt;
|
|
168
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
169
|
+
exclusiveBytes: z.ZodInt;
|
|
170
|
+
sharedBytes: z.ZodInt;
|
|
171
|
+
measuredAt: z.ZodDate;
|
|
172
|
+
isPartial: z.ZodBoolean;
|
|
173
|
+
isUpperBound: z.ZodBoolean;
|
|
174
|
+
}, z.core.$strip>>;
|
|
147
175
|
ip: z.ZodIPv4;
|
|
148
176
|
slot: z.ZodInt;
|
|
149
177
|
port: z.ZodInt;
|
|
@@ -175,6 +203,7 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
175
203
|
label: z.ZodOptional<z.ZodString>;
|
|
176
204
|
createdAt: z.ZodDate;
|
|
177
205
|
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
206
|
+
diskMib: z.ZodInt;
|
|
178
207
|
}, z.core.$strip>;
|
|
179
208
|
}, z.core.$strip>, z.ZodObject<{
|
|
180
209
|
v: z.ZodLiteral<1>;
|
|
@@ -186,6 +215,7 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
186
215
|
label: z.ZodOptional<z.ZodString>;
|
|
187
216
|
createdAt: z.ZodDate;
|
|
188
217
|
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
218
|
+
diskMib: z.ZodInt;
|
|
189
219
|
}, z.core.$strip>;
|
|
190
220
|
}, z.core.$strip>, z.ZodObject<{
|
|
191
221
|
v: z.ZodLiteral<1>;
|
|
@@ -223,6 +253,7 @@ declare const impContract: {
|
|
|
223
253
|
image: z.ZodOptional<z.ZodString>;
|
|
224
254
|
vcpus: z.ZodOptional<z.ZodInt>;
|
|
225
255
|
memoryMib: z.ZodOptional<z.ZodInt>;
|
|
256
|
+
diskMib: z.ZodOptional<z.ZodInt>;
|
|
226
257
|
httpPort: z.ZodOptional<z.ZodInt>;
|
|
227
258
|
}, z.core.$strip>, z.ZodObject<{
|
|
228
259
|
id: z.ZodString;
|
|
@@ -237,6 +268,14 @@ declare const impContract: {
|
|
|
237
268
|
}>;
|
|
238
269
|
vcpus: z.ZodInt;
|
|
239
270
|
memoryMib: z.ZodInt;
|
|
271
|
+
diskMib: z.ZodInt;
|
|
272
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
273
|
+
exclusiveBytes: z.ZodInt;
|
|
274
|
+
sharedBytes: z.ZodInt;
|
|
275
|
+
measuredAt: z.ZodDate;
|
|
276
|
+
isPartial: z.ZodBoolean;
|
|
277
|
+
isUpperBound: z.ZodBoolean;
|
|
278
|
+
}, z.core.$strip>>;
|
|
240
279
|
ip: z.ZodIPv4;
|
|
241
280
|
slot: z.ZodInt;
|
|
242
281
|
port: z.ZodInt;
|
|
@@ -269,6 +308,7 @@ declare const impContract: {
|
|
|
269
308
|
imp: "imp";
|
|
270
309
|
secret: "secret";
|
|
271
310
|
session: "session";
|
|
311
|
+
token: "token";
|
|
272
312
|
}>;
|
|
273
313
|
name: z.ZodString;
|
|
274
314
|
}, z.core.$strip>;
|
|
@@ -284,6 +324,7 @@ declare const impContract: {
|
|
|
284
324
|
imp: "imp";
|
|
285
325
|
secret: "secret";
|
|
286
326
|
session: "session";
|
|
327
|
+
token: "token";
|
|
287
328
|
}>;
|
|
288
329
|
name: z.ZodString;
|
|
289
330
|
}, z.core.$strip>;
|
|
@@ -326,6 +367,15 @@ declare const impContract: {
|
|
|
326
367
|
}>>;
|
|
327
368
|
}, z.core.$strip>;
|
|
328
369
|
};
|
|
370
|
+
DISK_FULL: {
|
|
371
|
+
readonly message: "Not enough free disk on the host";
|
|
372
|
+
readonly status: 507;
|
|
373
|
+
readonly data: z.ZodObject<{
|
|
374
|
+
availableBytes: z.ZodInt;
|
|
375
|
+
reserveBytes: z.ZodInt;
|
|
376
|
+
requestedBytes: z.ZodInt;
|
|
377
|
+
}, z.core.$strip>;
|
|
378
|
+
};
|
|
329
379
|
AGENT_OUTDATED: {
|
|
330
380
|
readonly message: "The imp's agent is too old for this";
|
|
331
381
|
readonly status: 409;
|
|
@@ -344,6 +394,14 @@ declare const impContract: {
|
|
|
344
394
|
}>;
|
|
345
395
|
vcpus: z.ZodInt;
|
|
346
396
|
memoryMib: z.ZodInt;
|
|
397
|
+
diskMib: z.ZodInt;
|
|
398
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
399
|
+
exclusiveBytes: z.ZodInt;
|
|
400
|
+
sharedBytes: z.ZodInt;
|
|
401
|
+
measuredAt: z.ZodDate;
|
|
402
|
+
isPartial: z.ZodBoolean;
|
|
403
|
+
isUpperBound: z.ZodBoolean;
|
|
404
|
+
}, z.core.$strip>>;
|
|
347
405
|
ip: z.ZodIPv4;
|
|
348
406
|
slot: z.ZodInt;
|
|
349
407
|
port: z.ZodInt;
|
|
@@ -376,6 +434,7 @@ declare const impContract: {
|
|
|
376
434
|
imp: "imp";
|
|
377
435
|
secret: "secret";
|
|
378
436
|
session: "session";
|
|
437
|
+
token: "token";
|
|
379
438
|
}>;
|
|
380
439
|
name: z.ZodString;
|
|
381
440
|
}, z.core.$strip>;
|
|
@@ -391,6 +450,7 @@ declare const impContract: {
|
|
|
391
450
|
imp: "imp";
|
|
392
451
|
secret: "secret";
|
|
393
452
|
session: "session";
|
|
453
|
+
token: "token";
|
|
394
454
|
}>;
|
|
395
455
|
name: z.ZodString;
|
|
396
456
|
}, z.core.$strip>;
|
|
@@ -433,6 +493,15 @@ declare const impContract: {
|
|
|
433
493
|
}>>;
|
|
434
494
|
}, z.core.$strip>;
|
|
435
495
|
};
|
|
496
|
+
DISK_FULL: {
|
|
497
|
+
readonly message: "Not enough free disk on the host";
|
|
498
|
+
readonly status: 507;
|
|
499
|
+
readonly data: z.ZodObject<{
|
|
500
|
+
availableBytes: z.ZodInt;
|
|
501
|
+
reserveBytes: z.ZodInt;
|
|
502
|
+
requestedBytes: z.ZodInt;
|
|
503
|
+
}, z.core.$strip>;
|
|
504
|
+
};
|
|
436
505
|
AGENT_OUTDATED: {
|
|
437
506
|
readonly message: "The imp's agent is too old for this";
|
|
438
507
|
readonly status: 409;
|
|
@@ -453,6 +522,14 @@ declare const impContract: {
|
|
|
453
522
|
}>;
|
|
454
523
|
vcpus: z.ZodInt;
|
|
455
524
|
memoryMib: z.ZodInt;
|
|
525
|
+
diskMib: z.ZodInt;
|
|
526
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
527
|
+
exclusiveBytes: z.ZodInt;
|
|
528
|
+
sharedBytes: z.ZodInt;
|
|
529
|
+
measuredAt: z.ZodDate;
|
|
530
|
+
isPartial: z.ZodBoolean;
|
|
531
|
+
isUpperBound: z.ZodBoolean;
|
|
532
|
+
}, z.core.$strip>>;
|
|
456
533
|
ip: z.ZodIPv4;
|
|
457
534
|
slot: z.ZodInt;
|
|
458
535
|
port: z.ZodInt;
|
|
@@ -485,6 +562,7 @@ declare const impContract: {
|
|
|
485
562
|
imp: "imp";
|
|
486
563
|
secret: "secret";
|
|
487
564
|
session: "session";
|
|
565
|
+
token: "token";
|
|
488
566
|
}>;
|
|
489
567
|
name: z.ZodString;
|
|
490
568
|
}, z.core.$strip>;
|
|
@@ -500,6 +578,7 @@ declare const impContract: {
|
|
|
500
578
|
imp: "imp";
|
|
501
579
|
secret: "secret";
|
|
502
580
|
session: "session";
|
|
581
|
+
token: "token";
|
|
503
582
|
}>;
|
|
504
583
|
name: z.ZodString;
|
|
505
584
|
}, z.core.$strip>;
|
|
@@ -542,6 +621,15 @@ declare const impContract: {
|
|
|
542
621
|
}>>;
|
|
543
622
|
}, z.core.$strip>;
|
|
544
623
|
};
|
|
624
|
+
DISK_FULL: {
|
|
625
|
+
readonly message: "Not enough free disk on the host";
|
|
626
|
+
readonly status: 507;
|
|
627
|
+
readonly data: z.ZodObject<{
|
|
628
|
+
availableBytes: z.ZodInt;
|
|
629
|
+
reserveBytes: z.ZodInt;
|
|
630
|
+
requestedBytes: z.ZodInt;
|
|
631
|
+
}, z.core.$strip>;
|
|
632
|
+
};
|
|
545
633
|
AGENT_OUTDATED: {
|
|
546
634
|
readonly message: "The imp's agent is too old for this";
|
|
547
635
|
readonly status: 409;
|
|
@@ -561,6 +649,7 @@ declare const impContract: {
|
|
|
561
649
|
imp: "imp";
|
|
562
650
|
secret: "secret";
|
|
563
651
|
session: "session";
|
|
652
|
+
token: "token";
|
|
564
653
|
}>;
|
|
565
654
|
name: z.ZodString;
|
|
566
655
|
}, z.core.$strip>;
|
|
@@ -576,6 +665,7 @@ declare const impContract: {
|
|
|
576
665
|
imp: "imp";
|
|
577
666
|
secret: "secret";
|
|
578
667
|
session: "session";
|
|
668
|
+
token: "token";
|
|
579
669
|
}>;
|
|
580
670
|
name: z.ZodString;
|
|
581
671
|
}, z.core.$strip>;
|
|
@@ -618,6 +708,15 @@ declare const impContract: {
|
|
|
618
708
|
}>>;
|
|
619
709
|
}, z.core.$strip>;
|
|
620
710
|
};
|
|
711
|
+
DISK_FULL: {
|
|
712
|
+
readonly message: "Not enough free disk on the host";
|
|
713
|
+
readonly status: 507;
|
|
714
|
+
readonly data: z.ZodObject<{
|
|
715
|
+
availableBytes: z.ZodInt;
|
|
716
|
+
reserveBytes: z.ZodInt;
|
|
717
|
+
requestedBytes: z.ZodInt;
|
|
718
|
+
}, z.core.$strip>;
|
|
719
|
+
};
|
|
621
720
|
AGENT_OUTDATED: {
|
|
622
721
|
readonly message: "The imp's agent is too old for this";
|
|
623
722
|
readonly status: 409;
|
|
@@ -638,6 +737,14 @@ declare const impContract: {
|
|
|
638
737
|
}>;
|
|
639
738
|
vcpus: z.ZodInt;
|
|
640
739
|
memoryMib: z.ZodInt;
|
|
740
|
+
diskMib: z.ZodInt;
|
|
741
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
742
|
+
exclusiveBytes: z.ZodInt;
|
|
743
|
+
sharedBytes: z.ZodInt;
|
|
744
|
+
measuredAt: z.ZodDate;
|
|
745
|
+
isPartial: z.ZodBoolean;
|
|
746
|
+
isUpperBound: z.ZodBoolean;
|
|
747
|
+
}, z.core.$strip>>;
|
|
641
748
|
ip: z.ZodIPv4;
|
|
642
749
|
slot: z.ZodInt;
|
|
643
750
|
port: z.ZodInt;
|
|
@@ -670,6 +777,7 @@ declare const impContract: {
|
|
|
670
777
|
imp: "imp";
|
|
671
778
|
secret: "secret";
|
|
672
779
|
session: "session";
|
|
780
|
+
token: "token";
|
|
673
781
|
}>;
|
|
674
782
|
name: z.ZodString;
|
|
675
783
|
}, z.core.$strip>;
|
|
@@ -685,6 +793,7 @@ declare const impContract: {
|
|
|
685
793
|
imp: "imp";
|
|
686
794
|
secret: "secret";
|
|
687
795
|
session: "session";
|
|
796
|
+
token: "token";
|
|
688
797
|
}>;
|
|
689
798
|
name: z.ZodString;
|
|
690
799
|
}, z.core.$strip>;
|
|
@@ -727,6 +836,15 @@ declare const impContract: {
|
|
|
727
836
|
}>>;
|
|
728
837
|
}, z.core.$strip>;
|
|
729
838
|
};
|
|
839
|
+
DISK_FULL: {
|
|
840
|
+
readonly message: "Not enough free disk on the host";
|
|
841
|
+
readonly status: 507;
|
|
842
|
+
readonly data: z.ZodObject<{
|
|
843
|
+
availableBytes: z.ZodInt;
|
|
844
|
+
reserveBytes: z.ZodInt;
|
|
845
|
+
requestedBytes: z.ZodInt;
|
|
846
|
+
}, z.core.$strip>;
|
|
847
|
+
};
|
|
730
848
|
AGENT_OUTDATED: {
|
|
731
849
|
readonly message: "The imp's agent is too old for this";
|
|
732
850
|
readonly status: 409;
|
|
@@ -747,6 +865,14 @@ declare const impContract: {
|
|
|
747
865
|
}>;
|
|
748
866
|
vcpus: z.ZodInt;
|
|
749
867
|
memoryMib: z.ZodInt;
|
|
868
|
+
diskMib: z.ZodInt;
|
|
869
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
870
|
+
exclusiveBytes: z.ZodInt;
|
|
871
|
+
sharedBytes: z.ZodInt;
|
|
872
|
+
measuredAt: z.ZodDate;
|
|
873
|
+
isPartial: z.ZodBoolean;
|
|
874
|
+
isUpperBound: z.ZodBoolean;
|
|
875
|
+
}, z.core.$strip>>;
|
|
750
876
|
ip: z.ZodIPv4;
|
|
751
877
|
slot: z.ZodInt;
|
|
752
878
|
port: z.ZodInt;
|
|
@@ -779,6 +905,7 @@ declare const impContract: {
|
|
|
779
905
|
imp: "imp";
|
|
780
906
|
secret: "secret";
|
|
781
907
|
session: "session";
|
|
908
|
+
token: "token";
|
|
782
909
|
}>;
|
|
783
910
|
name: z.ZodString;
|
|
784
911
|
}, z.core.$strip>;
|
|
@@ -794,6 +921,7 @@ declare const impContract: {
|
|
|
794
921
|
imp: "imp";
|
|
795
922
|
secret: "secret";
|
|
796
923
|
session: "session";
|
|
924
|
+
token: "token";
|
|
797
925
|
}>;
|
|
798
926
|
name: z.ZodString;
|
|
799
927
|
}, z.core.$strip>;
|
|
@@ -836,6 +964,15 @@ declare const impContract: {
|
|
|
836
964
|
}>>;
|
|
837
965
|
}, z.core.$strip>;
|
|
838
966
|
};
|
|
967
|
+
DISK_FULL: {
|
|
968
|
+
readonly message: "Not enough free disk on the host";
|
|
969
|
+
readonly status: 507;
|
|
970
|
+
readonly data: z.ZodObject<{
|
|
971
|
+
availableBytes: z.ZodInt;
|
|
972
|
+
reserveBytes: z.ZodInt;
|
|
973
|
+
requestedBytes: z.ZodInt;
|
|
974
|
+
}, z.core.$strip>;
|
|
975
|
+
};
|
|
839
976
|
AGENT_OUTDATED: {
|
|
840
977
|
readonly message: "The imp's agent is too old for this";
|
|
841
978
|
readonly status: 409;
|
|
@@ -856,6 +993,14 @@ declare const impContract: {
|
|
|
856
993
|
}>;
|
|
857
994
|
vcpus: z.ZodInt;
|
|
858
995
|
memoryMib: z.ZodInt;
|
|
996
|
+
diskMib: z.ZodInt;
|
|
997
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
998
|
+
exclusiveBytes: z.ZodInt;
|
|
999
|
+
sharedBytes: z.ZodInt;
|
|
1000
|
+
measuredAt: z.ZodDate;
|
|
1001
|
+
isPartial: z.ZodBoolean;
|
|
1002
|
+
isUpperBound: z.ZodBoolean;
|
|
1003
|
+
}, z.core.$strip>>;
|
|
859
1004
|
ip: z.ZodIPv4;
|
|
860
1005
|
slot: z.ZodInt;
|
|
861
1006
|
port: z.ZodInt;
|
|
@@ -888,6 +1033,7 @@ declare const impContract: {
|
|
|
888
1033
|
imp: "imp";
|
|
889
1034
|
secret: "secret";
|
|
890
1035
|
session: "session";
|
|
1036
|
+
token: "token";
|
|
891
1037
|
}>;
|
|
892
1038
|
name: z.ZodString;
|
|
893
1039
|
}, z.core.$strip>;
|
|
@@ -903,6 +1049,7 @@ declare const impContract: {
|
|
|
903
1049
|
imp: "imp";
|
|
904
1050
|
secret: "secret";
|
|
905
1051
|
session: "session";
|
|
1052
|
+
token: "token";
|
|
906
1053
|
}>;
|
|
907
1054
|
name: z.ZodString;
|
|
908
1055
|
}, z.core.$strip>;
|
|
@@ -945,6 +1092,15 @@ declare const impContract: {
|
|
|
945
1092
|
}>>;
|
|
946
1093
|
}, z.core.$strip>;
|
|
947
1094
|
};
|
|
1095
|
+
DISK_FULL: {
|
|
1096
|
+
readonly message: "Not enough free disk on the host";
|
|
1097
|
+
readonly status: 507;
|
|
1098
|
+
readonly data: z.ZodObject<{
|
|
1099
|
+
availableBytes: z.ZodInt;
|
|
1100
|
+
reserveBytes: z.ZodInt;
|
|
1101
|
+
requestedBytes: z.ZodInt;
|
|
1102
|
+
}, z.core.$strip>;
|
|
1103
|
+
};
|
|
948
1104
|
AGENT_OUTDATED: {
|
|
949
1105
|
readonly message: "The imp's agent is too old for this";
|
|
950
1106
|
readonly status: 409;
|
|
@@ -966,6 +1122,14 @@ declare const impContract: {
|
|
|
966
1122
|
}>;
|
|
967
1123
|
vcpus: z.ZodInt;
|
|
968
1124
|
memoryMib: z.ZodInt;
|
|
1125
|
+
diskMib: z.ZodInt;
|
|
1126
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
1127
|
+
exclusiveBytes: z.ZodInt;
|
|
1128
|
+
sharedBytes: z.ZodInt;
|
|
1129
|
+
measuredAt: z.ZodDate;
|
|
1130
|
+
isPartial: z.ZodBoolean;
|
|
1131
|
+
isUpperBound: z.ZodBoolean;
|
|
1132
|
+
}, z.core.$strip>>;
|
|
969
1133
|
ip: z.ZodIPv4;
|
|
970
1134
|
slot: z.ZodInt;
|
|
971
1135
|
port: z.ZodInt;
|
|
@@ -998,6 +1162,7 @@ declare const impContract: {
|
|
|
998
1162
|
imp: "imp";
|
|
999
1163
|
secret: "secret";
|
|
1000
1164
|
session: "session";
|
|
1165
|
+
token: "token";
|
|
1001
1166
|
}>;
|
|
1002
1167
|
name: z.ZodString;
|
|
1003
1168
|
}, z.core.$strip>;
|
|
@@ -1013,6 +1178,7 @@ declare const impContract: {
|
|
|
1013
1178
|
imp: "imp";
|
|
1014
1179
|
secret: "secret";
|
|
1015
1180
|
session: "session";
|
|
1181
|
+
token: "token";
|
|
1016
1182
|
}>;
|
|
1017
1183
|
name: z.ZodString;
|
|
1018
1184
|
}, z.core.$strip>;
|
|
@@ -1055,6 +1221,15 @@ declare const impContract: {
|
|
|
1055
1221
|
}>>;
|
|
1056
1222
|
}, z.core.$strip>;
|
|
1057
1223
|
};
|
|
1224
|
+
DISK_FULL: {
|
|
1225
|
+
readonly message: "Not enough free disk on the host";
|
|
1226
|
+
readonly status: 507;
|
|
1227
|
+
readonly data: z.ZodObject<{
|
|
1228
|
+
availableBytes: z.ZodInt;
|
|
1229
|
+
reserveBytes: z.ZodInt;
|
|
1230
|
+
requestedBytes: z.ZodInt;
|
|
1231
|
+
}, z.core.$strip>;
|
|
1232
|
+
};
|
|
1058
1233
|
AGENT_OUTDATED: {
|
|
1059
1234
|
readonly message: "The imp's agent is too old for this";
|
|
1060
1235
|
readonly status: 409;
|
|
@@ -1076,6 +1251,143 @@ declare const impContract: {
|
|
|
1076
1251
|
}>;
|
|
1077
1252
|
vcpus: z.ZodInt;
|
|
1078
1253
|
memoryMib: z.ZodInt;
|
|
1254
|
+
diskMib: z.ZodInt;
|
|
1255
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
1256
|
+
exclusiveBytes: z.ZodInt;
|
|
1257
|
+
sharedBytes: z.ZodInt;
|
|
1258
|
+
measuredAt: z.ZodDate;
|
|
1259
|
+
isPartial: z.ZodBoolean;
|
|
1260
|
+
isUpperBound: z.ZodBoolean;
|
|
1261
|
+
}, z.core.$strip>>;
|
|
1262
|
+
ip: z.ZodIPv4;
|
|
1263
|
+
slot: z.ZodInt;
|
|
1264
|
+
port: z.ZodInt;
|
|
1265
|
+
httpPort: z.ZodInt;
|
|
1266
|
+
url: z.ZodURL;
|
|
1267
|
+
createdAt: z.ZodDate;
|
|
1268
|
+
lastActiveAt: z.ZodDate;
|
|
1269
|
+
ramMib: z.ZodOptional<z.ZodInt>;
|
|
1270
|
+
rssMib: z.ZodOptional<z.ZodInt>;
|
|
1271
|
+
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
1272
|
+
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
1273
|
+
error: z.ZodOptional<z.ZodString>;
|
|
1274
|
+
sessions: z.ZodOptional<z.ZodInt>;
|
|
1275
|
+
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
1276
|
+
outdated: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodEnum<{
|
|
1277
|
+
agent: "agent";
|
|
1278
|
+
firecracker: "firecracker";
|
|
1279
|
+
impd: "impd";
|
|
1280
|
+
kernel: "kernel";
|
|
1281
|
+
}>>>>;
|
|
1282
|
+
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
1283
|
+
NOT_FOUND: {
|
|
1284
|
+
readonly message: "Not found";
|
|
1285
|
+
readonly data: z.ZodObject<{
|
|
1286
|
+
kind: z.ZodEnum<{
|
|
1287
|
+
backup: "backup";
|
|
1288
|
+
checkpoint: "checkpoint";
|
|
1289
|
+
grant: "grant";
|
|
1290
|
+
image: "image";
|
|
1291
|
+
imp: "imp";
|
|
1292
|
+
secret: "secret";
|
|
1293
|
+
session: "session";
|
|
1294
|
+
token: "token";
|
|
1295
|
+
}>;
|
|
1296
|
+
name: z.ZodString;
|
|
1297
|
+
}, z.core.$strip>;
|
|
1298
|
+
};
|
|
1299
|
+
CONFLICT: {
|
|
1300
|
+
readonly message: "Already exists";
|
|
1301
|
+
readonly data: z.ZodObject<{
|
|
1302
|
+
kind: z.ZodEnum<{
|
|
1303
|
+
backup: "backup";
|
|
1304
|
+
checkpoint: "checkpoint";
|
|
1305
|
+
grant: "grant";
|
|
1306
|
+
image: "image";
|
|
1307
|
+
imp: "imp";
|
|
1308
|
+
secret: "secret";
|
|
1309
|
+
session: "session";
|
|
1310
|
+
token: "token";
|
|
1311
|
+
}>;
|
|
1312
|
+
name: z.ZodString;
|
|
1313
|
+
}, z.core.$strip>;
|
|
1314
|
+
};
|
|
1315
|
+
FORBIDDEN: {
|
|
1316
|
+
readonly message: "Not allowed";
|
|
1317
|
+
};
|
|
1318
|
+
PRECONDITION_FAILED: {
|
|
1319
|
+
readonly message: "Not possible on this host";
|
|
1320
|
+
};
|
|
1321
|
+
RAM_BUDGET_EXCEEDED: {
|
|
1322
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
1323
|
+
readonly status: 503;
|
|
1324
|
+
readonly data: z.ZodObject<{
|
|
1325
|
+
budgetMib: z.ZodInt;
|
|
1326
|
+
usedMib: z.ZodInt;
|
|
1327
|
+
requestedMib: z.ZodInt;
|
|
1328
|
+
}, z.core.$strip>;
|
|
1329
|
+
};
|
|
1330
|
+
SERVICE_UNAVAILABLE: {
|
|
1331
|
+
readonly message: "impd is stopping";
|
|
1332
|
+
};
|
|
1333
|
+
INVALID_STATE: {
|
|
1334
|
+
readonly message: "The imp is not in a state that allows this";
|
|
1335
|
+
readonly status: 409;
|
|
1336
|
+
readonly data: z.ZodObject<{
|
|
1337
|
+
state: z.ZodEnum<{
|
|
1338
|
+
creating: "creating";
|
|
1339
|
+
error: "error";
|
|
1340
|
+
running: "running";
|
|
1341
|
+
sleeping: "sleeping";
|
|
1342
|
+
stopped: "stopped";
|
|
1343
|
+
}>;
|
|
1344
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
1345
|
+
creating: "creating";
|
|
1346
|
+
error: "error";
|
|
1347
|
+
running: "running";
|
|
1348
|
+
sleeping: "sleeping";
|
|
1349
|
+
stopped: "stopped";
|
|
1350
|
+
}>>;
|
|
1351
|
+
}, z.core.$strip>;
|
|
1352
|
+
};
|
|
1353
|
+
DISK_FULL: {
|
|
1354
|
+
readonly message: "Not enough free disk on the host";
|
|
1355
|
+
readonly status: 507;
|
|
1356
|
+
readonly data: z.ZodObject<{
|
|
1357
|
+
availableBytes: z.ZodInt;
|
|
1358
|
+
reserveBytes: z.ZodInt;
|
|
1359
|
+
requestedBytes: z.ZodInt;
|
|
1360
|
+
}, z.core.$strip>;
|
|
1361
|
+
};
|
|
1362
|
+
AGENT_OUTDATED: {
|
|
1363
|
+
readonly message: "The imp's agent is too old for this";
|
|
1364
|
+
readonly status: 409;
|
|
1365
|
+
};
|
|
1366
|
+
}>, Record<never, never>>;
|
|
1367
|
+
resizeDisk: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
1368
|
+
name: z.ZodString;
|
|
1369
|
+
diskMib: z.ZodInt;
|
|
1370
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
1371
|
+
id: z.ZodString;
|
|
1372
|
+
name: z.ZodString;
|
|
1373
|
+
image: z.ZodString;
|
|
1374
|
+
state: z.ZodEnum<{
|
|
1375
|
+
creating: "creating";
|
|
1376
|
+
error: "error";
|
|
1377
|
+
running: "running";
|
|
1378
|
+
sleeping: "sleeping";
|
|
1379
|
+
stopped: "stopped";
|
|
1380
|
+
}>;
|
|
1381
|
+
vcpus: z.ZodInt;
|
|
1382
|
+
memoryMib: z.ZodInt;
|
|
1383
|
+
diskMib: z.ZodInt;
|
|
1384
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
1385
|
+
exclusiveBytes: z.ZodInt;
|
|
1386
|
+
sharedBytes: z.ZodInt;
|
|
1387
|
+
measuredAt: z.ZodDate;
|
|
1388
|
+
isPartial: z.ZodBoolean;
|
|
1389
|
+
isUpperBound: z.ZodBoolean;
|
|
1390
|
+
}, z.core.$strip>>;
|
|
1079
1391
|
ip: z.ZodIPv4;
|
|
1080
1392
|
slot: z.ZodInt;
|
|
1081
1393
|
port: z.ZodInt;
|
|
@@ -1108,6 +1420,7 @@ declare const impContract: {
|
|
|
1108
1420
|
imp: "imp";
|
|
1109
1421
|
secret: "secret";
|
|
1110
1422
|
session: "session";
|
|
1423
|
+
token: "token";
|
|
1111
1424
|
}>;
|
|
1112
1425
|
name: z.ZodString;
|
|
1113
1426
|
}, z.core.$strip>;
|
|
@@ -1123,6 +1436,7 @@ declare const impContract: {
|
|
|
1123
1436
|
imp: "imp";
|
|
1124
1437
|
secret: "secret";
|
|
1125
1438
|
session: "session";
|
|
1439
|
+
token: "token";
|
|
1126
1440
|
}>;
|
|
1127
1441
|
name: z.ZodString;
|
|
1128
1442
|
}, z.core.$strip>;
|
|
@@ -1165,6 +1479,15 @@ declare const impContract: {
|
|
|
1165
1479
|
}>>;
|
|
1166
1480
|
}, z.core.$strip>;
|
|
1167
1481
|
};
|
|
1482
|
+
DISK_FULL: {
|
|
1483
|
+
readonly message: "Not enough free disk on the host";
|
|
1484
|
+
readonly status: 507;
|
|
1485
|
+
readonly data: z.ZodObject<{
|
|
1486
|
+
availableBytes: z.ZodInt;
|
|
1487
|
+
reserveBytes: z.ZodInt;
|
|
1488
|
+
requestedBytes: z.ZodInt;
|
|
1489
|
+
}, z.core.$strip>;
|
|
1490
|
+
};
|
|
1168
1491
|
AGENT_OUTDATED: {
|
|
1169
1492
|
readonly message: "The imp's agent is too old for this";
|
|
1170
1493
|
readonly status: 409;
|
|
@@ -1188,6 +1511,7 @@ declare const impContract: {
|
|
|
1188
1511
|
imp: "imp";
|
|
1189
1512
|
secret: "secret";
|
|
1190
1513
|
session: "session";
|
|
1514
|
+
token: "token";
|
|
1191
1515
|
}>;
|
|
1192
1516
|
name: z.ZodString;
|
|
1193
1517
|
}, z.core.$strip>;
|
|
@@ -1203,6 +1527,7 @@ declare const impContract: {
|
|
|
1203
1527
|
imp: "imp";
|
|
1204
1528
|
secret: "secret";
|
|
1205
1529
|
session: "session";
|
|
1530
|
+
token: "token";
|
|
1206
1531
|
}>;
|
|
1207
1532
|
name: z.ZodString;
|
|
1208
1533
|
}, z.core.$strip>;
|
|
@@ -1245,6 +1570,15 @@ declare const impContract: {
|
|
|
1245
1570
|
}>>;
|
|
1246
1571
|
}, z.core.$strip>;
|
|
1247
1572
|
};
|
|
1573
|
+
DISK_FULL: {
|
|
1574
|
+
readonly message: "Not enough free disk on the host";
|
|
1575
|
+
readonly status: 507;
|
|
1576
|
+
readonly data: z.ZodObject<{
|
|
1577
|
+
availableBytes: z.ZodInt;
|
|
1578
|
+
reserveBytes: z.ZodInt;
|
|
1579
|
+
requestedBytes: z.ZodInt;
|
|
1580
|
+
}, z.core.$strip>;
|
|
1581
|
+
};
|
|
1248
1582
|
AGENT_OUTDATED: {
|
|
1249
1583
|
readonly message: "The imp's agent is too old for this";
|
|
1250
1584
|
readonly status: 409;
|
|
@@ -1267,6 +1601,14 @@ declare const impContract: {
|
|
|
1267
1601
|
}>;
|
|
1268
1602
|
vcpus: z.ZodInt;
|
|
1269
1603
|
memoryMib: z.ZodInt;
|
|
1604
|
+
diskMib: z.ZodInt;
|
|
1605
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
1606
|
+
exclusiveBytes: z.ZodInt;
|
|
1607
|
+
sharedBytes: z.ZodInt;
|
|
1608
|
+
measuredAt: z.ZodDate;
|
|
1609
|
+
isPartial: z.ZodBoolean;
|
|
1610
|
+
isUpperBound: z.ZodBoolean;
|
|
1611
|
+
}, z.core.$strip>>;
|
|
1270
1612
|
ip: z.ZodIPv4;
|
|
1271
1613
|
slot: z.ZodInt;
|
|
1272
1614
|
port: z.ZodInt;
|
|
@@ -1299,6 +1641,7 @@ declare const impContract: {
|
|
|
1299
1641
|
imp: "imp";
|
|
1300
1642
|
secret: "secret";
|
|
1301
1643
|
session: "session";
|
|
1644
|
+
token: "token";
|
|
1302
1645
|
}>;
|
|
1303
1646
|
name: z.ZodString;
|
|
1304
1647
|
}, z.core.$strip>;
|
|
@@ -1314,6 +1657,7 @@ declare const impContract: {
|
|
|
1314
1657
|
imp: "imp";
|
|
1315
1658
|
secret: "secret";
|
|
1316
1659
|
session: "session";
|
|
1660
|
+
token: "token";
|
|
1317
1661
|
}>;
|
|
1318
1662
|
name: z.ZodString;
|
|
1319
1663
|
}, z.core.$strip>;
|
|
@@ -1356,6 +1700,15 @@ declare const impContract: {
|
|
|
1356
1700
|
}>>;
|
|
1357
1701
|
}, z.core.$strip>;
|
|
1358
1702
|
};
|
|
1703
|
+
DISK_FULL: {
|
|
1704
|
+
readonly message: "Not enough free disk on the host";
|
|
1705
|
+
readonly status: 507;
|
|
1706
|
+
readonly data: z.ZodObject<{
|
|
1707
|
+
availableBytes: z.ZodInt;
|
|
1708
|
+
reserveBytes: z.ZodInt;
|
|
1709
|
+
requestedBytes: z.ZodInt;
|
|
1710
|
+
}, z.core.$strip>;
|
|
1711
|
+
};
|
|
1359
1712
|
AGENT_OUTDATED: {
|
|
1360
1713
|
readonly message: "The imp's agent is too old for this";
|
|
1361
1714
|
readonly status: 409;
|
|
@@ -1371,6 +1724,7 @@ declare const impContract: {
|
|
|
1371
1724
|
label: z.ZodOptional<z.ZodString>;
|
|
1372
1725
|
createdAt: z.ZodDate;
|
|
1373
1726
|
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
1727
|
+
diskMib: z.ZodInt;
|
|
1374
1728
|
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
1375
1729
|
NOT_FOUND: {
|
|
1376
1730
|
readonly message: "Not found";
|
|
@@ -1383,6 +1737,7 @@ declare const impContract: {
|
|
|
1383
1737
|
imp: "imp";
|
|
1384
1738
|
secret: "secret";
|
|
1385
1739
|
session: "session";
|
|
1740
|
+
token: "token";
|
|
1386
1741
|
}>;
|
|
1387
1742
|
name: z.ZodString;
|
|
1388
1743
|
}, z.core.$strip>;
|
|
@@ -1398,6 +1753,7 @@ declare const impContract: {
|
|
|
1398
1753
|
imp: "imp";
|
|
1399
1754
|
secret: "secret";
|
|
1400
1755
|
session: "session";
|
|
1756
|
+
token: "token";
|
|
1401
1757
|
}>;
|
|
1402
1758
|
name: z.ZodString;
|
|
1403
1759
|
}, z.core.$strip>;
|
|
@@ -1440,6 +1796,15 @@ declare const impContract: {
|
|
|
1440
1796
|
}>>;
|
|
1441
1797
|
}, z.core.$strip>;
|
|
1442
1798
|
};
|
|
1799
|
+
DISK_FULL: {
|
|
1800
|
+
readonly message: "Not enough free disk on the host";
|
|
1801
|
+
readonly status: 507;
|
|
1802
|
+
readonly data: z.ZodObject<{
|
|
1803
|
+
availableBytes: z.ZodInt;
|
|
1804
|
+
reserveBytes: z.ZodInt;
|
|
1805
|
+
requestedBytes: z.ZodInt;
|
|
1806
|
+
}, z.core.$strip>;
|
|
1807
|
+
};
|
|
1443
1808
|
AGENT_OUTDATED: {
|
|
1444
1809
|
readonly message: "The imp's agent is too old for this";
|
|
1445
1810
|
readonly status: 409;
|
|
@@ -1452,6 +1817,7 @@ declare const impContract: {
|
|
|
1452
1817
|
label: z.ZodOptional<z.ZodString>;
|
|
1453
1818
|
createdAt: z.ZodDate;
|
|
1454
1819
|
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
1820
|
+
diskMib: z.ZodInt;
|
|
1455
1821
|
}, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
1456
1822
|
NOT_FOUND: {
|
|
1457
1823
|
readonly message: "Not found";
|
|
@@ -1464,6 +1830,7 @@ declare const impContract: {
|
|
|
1464
1830
|
imp: "imp";
|
|
1465
1831
|
secret: "secret";
|
|
1466
1832
|
session: "session";
|
|
1833
|
+
token: "token";
|
|
1467
1834
|
}>;
|
|
1468
1835
|
name: z.ZodString;
|
|
1469
1836
|
}, z.core.$strip>;
|
|
@@ -1479,6 +1846,7 @@ declare const impContract: {
|
|
|
1479
1846
|
imp: "imp";
|
|
1480
1847
|
secret: "secret";
|
|
1481
1848
|
session: "session";
|
|
1849
|
+
token: "token";
|
|
1482
1850
|
}>;
|
|
1483
1851
|
name: z.ZodString;
|
|
1484
1852
|
}, z.core.$strip>;
|
|
@@ -1521,6 +1889,15 @@ declare const impContract: {
|
|
|
1521
1889
|
}>>;
|
|
1522
1890
|
}, z.core.$strip>;
|
|
1523
1891
|
};
|
|
1892
|
+
DISK_FULL: {
|
|
1893
|
+
readonly message: "Not enough free disk on the host";
|
|
1894
|
+
readonly status: 507;
|
|
1895
|
+
readonly data: z.ZodObject<{
|
|
1896
|
+
availableBytes: z.ZodInt;
|
|
1897
|
+
reserveBytes: z.ZodInt;
|
|
1898
|
+
requestedBytes: z.ZodInt;
|
|
1899
|
+
}, z.core.$strip>;
|
|
1900
|
+
};
|
|
1524
1901
|
AGENT_OUTDATED: {
|
|
1525
1902
|
readonly message: "The imp's agent is too old for this";
|
|
1526
1903
|
readonly status: 409;
|
|
@@ -1542,6 +1919,14 @@ declare const impContract: {
|
|
|
1542
1919
|
}>;
|
|
1543
1920
|
vcpus: z.ZodInt;
|
|
1544
1921
|
memoryMib: z.ZodInt;
|
|
1922
|
+
diskMib: z.ZodInt;
|
|
1923
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
1924
|
+
exclusiveBytes: z.ZodInt;
|
|
1925
|
+
sharedBytes: z.ZodInt;
|
|
1926
|
+
measuredAt: z.ZodDate;
|
|
1927
|
+
isPartial: z.ZodBoolean;
|
|
1928
|
+
isUpperBound: z.ZodBoolean;
|
|
1929
|
+
}, z.core.$strip>>;
|
|
1545
1930
|
ip: z.ZodIPv4;
|
|
1546
1931
|
slot: z.ZodInt;
|
|
1547
1932
|
port: z.ZodInt;
|
|
@@ -1574,6 +1959,7 @@ declare const impContract: {
|
|
|
1574
1959
|
imp: "imp";
|
|
1575
1960
|
secret: "secret";
|
|
1576
1961
|
session: "session";
|
|
1962
|
+
token: "token";
|
|
1577
1963
|
}>;
|
|
1578
1964
|
name: z.ZodString;
|
|
1579
1965
|
}, z.core.$strip>;
|
|
@@ -1589,6 +1975,7 @@ declare const impContract: {
|
|
|
1589
1975
|
imp: "imp";
|
|
1590
1976
|
secret: "secret";
|
|
1591
1977
|
session: "session";
|
|
1978
|
+
token: "token";
|
|
1592
1979
|
}>;
|
|
1593
1980
|
name: z.ZodString;
|
|
1594
1981
|
}, z.core.$strip>;
|
|
@@ -1631,6 +2018,15 @@ declare const impContract: {
|
|
|
1631
2018
|
}>>;
|
|
1632
2019
|
}, z.core.$strip>;
|
|
1633
2020
|
};
|
|
2021
|
+
DISK_FULL: {
|
|
2022
|
+
readonly message: "Not enough free disk on the host";
|
|
2023
|
+
readonly status: 507;
|
|
2024
|
+
readonly data: z.ZodObject<{
|
|
2025
|
+
availableBytes: z.ZodInt;
|
|
2026
|
+
reserveBytes: z.ZodInt;
|
|
2027
|
+
requestedBytes: z.ZodInt;
|
|
2028
|
+
}, z.core.$strip>;
|
|
2029
|
+
};
|
|
1634
2030
|
AGENT_OUTDATED: {
|
|
1635
2031
|
readonly message: "The imp's agent is too old for this";
|
|
1636
2032
|
readonly status: 409;
|
|
@@ -1651,6 +2047,7 @@ declare const impContract: {
|
|
|
1651
2047
|
imp: "imp";
|
|
1652
2048
|
secret: "secret";
|
|
1653
2049
|
session: "session";
|
|
2050
|
+
token: "token";
|
|
1654
2051
|
}>;
|
|
1655
2052
|
name: z.ZodString;
|
|
1656
2053
|
}, z.core.$strip>;
|
|
@@ -1666,6 +2063,7 @@ declare const impContract: {
|
|
|
1666
2063
|
imp: "imp";
|
|
1667
2064
|
secret: "secret";
|
|
1668
2065
|
session: "session";
|
|
2066
|
+
token: "token";
|
|
1669
2067
|
}>;
|
|
1670
2068
|
name: z.ZodString;
|
|
1671
2069
|
}, z.core.$strip>;
|
|
@@ -1708,6 +2106,15 @@ declare const impContract: {
|
|
|
1708
2106
|
}>>;
|
|
1709
2107
|
}, z.core.$strip>;
|
|
1710
2108
|
};
|
|
2109
|
+
DISK_FULL: {
|
|
2110
|
+
readonly message: "Not enough free disk on the host";
|
|
2111
|
+
readonly status: 507;
|
|
2112
|
+
readonly data: z.ZodObject<{
|
|
2113
|
+
availableBytes: z.ZodInt;
|
|
2114
|
+
reserveBytes: z.ZodInt;
|
|
2115
|
+
requestedBytes: z.ZodInt;
|
|
2116
|
+
}, z.core.$strip>;
|
|
2117
|
+
};
|
|
1711
2118
|
AGENT_OUTDATED: {
|
|
1712
2119
|
readonly message: "The imp's agent is too old for this";
|
|
1713
2120
|
readonly status: 409;
|
|
@@ -1736,6 +2143,7 @@ declare const impContract: {
|
|
|
1736
2143
|
imp: "imp";
|
|
1737
2144
|
secret: "secret";
|
|
1738
2145
|
session: "session";
|
|
2146
|
+
token: "token";
|
|
1739
2147
|
}>;
|
|
1740
2148
|
name: z.ZodString;
|
|
1741
2149
|
}, z.core.$strip>;
|
|
@@ -1751,6 +2159,7 @@ declare const impContract: {
|
|
|
1751
2159
|
imp: "imp";
|
|
1752
2160
|
secret: "secret";
|
|
1753
2161
|
session: "session";
|
|
2162
|
+
token: "token";
|
|
1754
2163
|
}>;
|
|
1755
2164
|
name: z.ZodString;
|
|
1756
2165
|
}, z.core.$strip>;
|
|
@@ -1793,6 +2202,15 @@ declare const impContract: {
|
|
|
1793
2202
|
}>>;
|
|
1794
2203
|
}, z.core.$strip>;
|
|
1795
2204
|
};
|
|
2205
|
+
DISK_FULL: {
|
|
2206
|
+
readonly message: "Not enough free disk on the host";
|
|
2207
|
+
readonly status: 507;
|
|
2208
|
+
readonly data: z.ZodObject<{
|
|
2209
|
+
availableBytes: z.ZodInt;
|
|
2210
|
+
reserveBytes: z.ZodInt;
|
|
2211
|
+
requestedBytes: z.ZodInt;
|
|
2212
|
+
}, z.core.$strip>;
|
|
2213
|
+
};
|
|
1796
2214
|
AGENT_OUTDATED: {
|
|
1797
2215
|
readonly message: "The imp's agent is too old for this";
|
|
1798
2216
|
readonly status: 409;
|
|
@@ -1822,6 +2240,7 @@ declare const impContract: {
|
|
|
1822
2240
|
imp: "imp";
|
|
1823
2241
|
secret: "secret";
|
|
1824
2242
|
session: "session";
|
|
2243
|
+
token: "token";
|
|
1825
2244
|
}>;
|
|
1826
2245
|
name: z.ZodString;
|
|
1827
2246
|
}, z.core.$strip>;
|
|
@@ -1837,6 +2256,7 @@ declare const impContract: {
|
|
|
1837
2256
|
imp: "imp";
|
|
1838
2257
|
secret: "secret";
|
|
1839
2258
|
session: "session";
|
|
2259
|
+
token: "token";
|
|
1840
2260
|
}>;
|
|
1841
2261
|
name: z.ZodString;
|
|
1842
2262
|
}, z.core.$strip>;
|
|
@@ -1879,6 +2299,15 @@ declare const impContract: {
|
|
|
1879
2299
|
}>>;
|
|
1880
2300
|
}, z.core.$strip>;
|
|
1881
2301
|
};
|
|
2302
|
+
DISK_FULL: {
|
|
2303
|
+
readonly message: "Not enough free disk on the host";
|
|
2304
|
+
readonly status: 507;
|
|
2305
|
+
readonly data: z.ZodObject<{
|
|
2306
|
+
availableBytes: z.ZodInt;
|
|
2307
|
+
reserveBytes: z.ZodInt;
|
|
2308
|
+
requestedBytes: z.ZodInt;
|
|
2309
|
+
}, z.core.$strip>;
|
|
2310
|
+
};
|
|
1882
2311
|
AGENT_OUTDATED: {
|
|
1883
2312
|
readonly message: "The imp's agent is too old for this";
|
|
1884
2313
|
readonly status: 409;
|
|
@@ -1904,6 +2333,14 @@ declare const impContract: {
|
|
|
1904
2333
|
}>;
|
|
1905
2334
|
vcpus: z.ZodInt;
|
|
1906
2335
|
memoryMib: z.ZodInt;
|
|
2336
|
+
diskMib: z.ZodInt;
|
|
2337
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
2338
|
+
exclusiveBytes: z.ZodInt;
|
|
2339
|
+
sharedBytes: z.ZodInt;
|
|
2340
|
+
measuredAt: z.ZodDate;
|
|
2341
|
+
isPartial: z.ZodBoolean;
|
|
2342
|
+
isUpperBound: z.ZodBoolean;
|
|
2343
|
+
}, z.core.$strip>>;
|
|
1907
2344
|
ip: z.ZodIPv4;
|
|
1908
2345
|
slot: z.ZodInt;
|
|
1909
2346
|
port: z.ZodInt;
|
|
@@ -1942,6 +2379,7 @@ declare const impContract: {
|
|
|
1942
2379
|
imp: "imp";
|
|
1943
2380
|
secret: "secret";
|
|
1944
2381
|
session: "session";
|
|
2382
|
+
token: "token";
|
|
1945
2383
|
}>;
|
|
1946
2384
|
name: z.ZodString;
|
|
1947
2385
|
}, z.core.$strip>;
|
|
@@ -1957,6 +2395,7 @@ declare const impContract: {
|
|
|
1957
2395
|
imp: "imp";
|
|
1958
2396
|
secret: "secret";
|
|
1959
2397
|
session: "session";
|
|
2398
|
+
token: "token";
|
|
1960
2399
|
}>;
|
|
1961
2400
|
name: z.ZodString;
|
|
1962
2401
|
}, z.core.$strip>;
|
|
@@ -1999,6 +2438,15 @@ declare const impContract: {
|
|
|
1999
2438
|
}>>;
|
|
2000
2439
|
}, z.core.$strip>;
|
|
2001
2440
|
};
|
|
2441
|
+
DISK_FULL: {
|
|
2442
|
+
readonly message: "Not enough free disk on the host";
|
|
2443
|
+
readonly status: 507;
|
|
2444
|
+
readonly data: z.ZodObject<{
|
|
2445
|
+
availableBytes: z.ZodInt;
|
|
2446
|
+
reserveBytes: z.ZodInt;
|
|
2447
|
+
requestedBytes: z.ZodInt;
|
|
2448
|
+
}, z.core.$strip>;
|
|
2449
|
+
};
|
|
2002
2450
|
AGENT_OUTDATED: {
|
|
2003
2451
|
readonly message: "The imp's agent is too old for this";
|
|
2004
2452
|
readonly status: 409;
|
|
@@ -2018,6 +2466,7 @@ declare const impContract: {
|
|
|
2018
2466
|
imp: "imp";
|
|
2019
2467
|
secret: "secret";
|
|
2020
2468
|
session: "session";
|
|
2469
|
+
token: "token";
|
|
2021
2470
|
}>;
|
|
2022
2471
|
name: z.ZodString;
|
|
2023
2472
|
}, z.core.$strip>;
|
|
@@ -2033,6 +2482,7 @@ declare const impContract: {
|
|
|
2033
2482
|
imp: "imp";
|
|
2034
2483
|
secret: "secret";
|
|
2035
2484
|
session: "session";
|
|
2485
|
+
token: "token";
|
|
2036
2486
|
}>;
|
|
2037
2487
|
name: z.ZodString;
|
|
2038
2488
|
}, z.core.$strip>;
|
|
@@ -2075,6 +2525,15 @@ declare const impContract: {
|
|
|
2075
2525
|
}>>;
|
|
2076
2526
|
}, z.core.$strip>;
|
|
2077
2527
|
};
|
|
2528
|
+
DISK_FULL: {
|
|
2529
|
+
readonly message: "Not enough free disk on the host";
|
|
2530
|
+
readonly status: 507;
|
|
2531
|
+
readonly data: z.ZodObject<{
|
|
2532
|
+
availableBytes: z.ZodInt;
|
|
2533
|
+
reserveBytes: z.ZodInt;
|
|
2534
|
+
requestedBytes: z.ZodInt;
|
|
2535
|
+
}, z.core.$strip>;
|
|
2536
|
+
};
|
|
2078
2537
|
AGENT_OUTDATED: {
|
|
2079
2538
|
readonly message: "The imp's agent is too old for this";
|
|
2080
2539
|
readonly status: 409;
|
|
@@ -2101,6 +2560,7 @@ declare const impContract: {
|
|
|
2101
2560
|
imp: "imp";
|
|
2102
2561
|
secret: "secret";
|
|
2103
2562
|
session: "session";
|
|
2563
|
+
token: "token";
|
|
2104
2564
|
}>;
|
|
2105
2565
|
name: z.ZodString;
|
|
2106
2566
|
}, z.core.$strip>;
|
|
@@ -2116,6 +2576,7 @@ declare const impContract: {
|
|
|
2116
2576
|
imp: "imp";
|
|
2117
2577
|
secret: "secret";
|
|
2118
2578
|
session: "session";
|
|
2579
|
+
token: "token";
|
|
2119
2580
|
}>;
|
|
2120
2581
|
name: z.ZodString;
|
|
2121
2582
|
}, z.core.$strip>;
|
|
@@ -2158,6 +2619,15 @@ declare const impContract: {
|
|
|
2158
2619
|
}>>;
|
|
2159
2620
|
}, z.core.$strip>;
|
|
2160
2621
|
};
|
|
2622
|
+
DISK_FULL: {
|
|
2623
|
+
readonly message: "Not enough free disk on the host";
|
|
2624
|
+
readonly status: 507;
|
|
2625
|
+
readonly data: z.ZodObject<{
|
|
2626
|
+
availableBytes: z.ZodInt;
|
|
2627
|
+
reserveBytes: z.ZodInt;
|
|
2628
|
+
requestedBytes: z.ZodInt;
|
|
2629
|
+
}, z.core.$strip>;
|
|
2630
|
+
};
|
|
2161
2631
|
AGENT_OUTDATED: {
|
|
2162
2632
|
readonly message: "The imp's agent is too old for this";
|
|
2163
2633
|
readonly status: 409;
|
|
@@ -2185,6 +2655,7 @@ declare const impContract: {
|
|
|
2185
2655
|
imp: "imp";
|
|
2186
2656
|
secret: "secret";
|
|
2187
2657
|
session: "session";
|
|
2658
|
+
token: "token";
|
|
2188
2659
|
}>;
|
|
2189
2660
|
name: z.ZodString;
|
|
2190
2661
|
}, z.core.$strip>;
|
|
@@ -2200,6 +2671,7 @@ declare const impContract: {
|
|
|
2200
2671
|
imp: "imp";
|
|
2201
2672
|
secret: "secret";
|
|
2202
2673
|
session: "session";
|
|
2674
|
+
token: "token";
|
|
2203
2675
|
}>;
|
|
2204
2676
|
name: z.ZodString;
|
|
2205
2677
|
}, z.core.$strip>;
|
|
@@ -2242,6 +2714,15 @@ declare const impContract: {
|
|
|
2242
2714
|
}>>;
|
|
2243
2715
|
}, z.core.$strip>;
|
|
2244
2716
|
};
|
|
2717
|
+
DISK_FULL: {
|
|
2718
|
+
readonly message: "Not enough free disk on the host";
|
|
2719
|
+
readonly status: 507;
|
|
2720
|
+
readonly data: z.ZodObject<{
|
|
2721
|
+
availableBytes: z.ZodInt;
|
|
2722
|
+
reserveBytes: z.ZodInt;
|
|
2723
|
+
requestedBytes: z.ZodInt;
|
|
2724
|
+
}, z.core.$strip>;
|
|
2725
|
+
};
|
|
2245
2726
|
AGENT_OUTDATED: {
|
|
2246
2727
|
readonly message: "The imp's agent is too old for this";
|
|
2247
2728
|
readonly status: 409;
|
|
@@ -2270,6 +2751,7 @@ declare const impContract: {
|
|
|
2270
2751
|
imp: "imp";
|
|
2271
2752
|
secret: "secret";
|
|
2272
2753
|
session: "session";
|
|
2754
|
+
token: "token";
|
|
2273
2755
|
}>;
|
|
2274
2756
|
name: z.ZodString;
|
|
2275
2757
|
}, z.core.$strip>;
|
|
@@ -2285,6 +2767,7 @@ declare const impContract: {
|
|
|
2285
2767
|
imp: "imp";
|
|
2286
2768
|
secret: "secret";
|
|
2287
2769
|
session: "session";
|
|
2770
|
+
token: "token";
|
|
2288
2771
|
}>;
|
|
2289
2772
|
name: z.ZodString;
|
|
2290
2773
|
}, z.core.$strip>;
|
|
@@ -2327,6 +2810,15 @@ declare const impContract: {
|
|
|
2327
2810
|
}>>;
|
|
2328
2811
|
}, z.core.$strip>;
|
|
2329
2812
|
};
|
|
2813
|
+
DISK_FULL: {
|
|
2814
|
+
readonly message: "Not enough free disk on the host";
|
|
2815
|
+
readonly status: 507;
|
|
2816
|
+
readonly data: z.ZodObject<{
|
|
2817
|
+
availableBytes: z.ZodInt;
|
|
2818
|
+
reserveBytes: z.ZodInt;
|
|
2819
|
+
requestedBytes: z.ZodInt;
|
|
2820
|
+
}, z.core.$strip>;
|
|
2821
|
+
};
|
|
2330
2822
|
AGENT_OUTDATED: {
|
|
2331
2823
|
readonly message: "The imp's agent is too old for this";
|
|
2332
2824
|
readonly status: 409;
|
|
@@ -2346,6 +2838,7 @@ declare const impContract: {
|
|
|
2346
2838
|
imp: "imp";
|
|
2347
2839
|
secret: "secret";
|
|
2348
2840
|
session: "session";
|
|
2841
|
+
token: "token";
|
|
2349
2842
|
}>;
|
|
2350
2843
|
name: z.ZodString;
|
|
2351
2844
|
}, z.core.$strip>;
|
|
@@ -2361,6 +2854,7 @@ declare const impContract: {
|
|
|
2361
2854
|
imp: "imp";
|
|
2362
2855
|
secret: "secret";
|
|
2363
2856
|
session: "session";
|
|
2857
|
+
token: "token";
|
|
2364
2858
|
}>;
|
|
2365
2859
|
name: z.ZodString;
|
|
2366
2860
|
}, z.core.$strip>;
|
|
@@ -2403,6 +2897,15 @@ declare const impContract: {
|
|
|
2403
2897
|
}>>;
|
|
2404
2898
|
}, z.core.$strip>;
|
|
2405
2899
|
};
|
|
2900
|
+
DISK_FULL: {
|
|
2901
|
+
readonly message: "Not enough free disk on the host";
|
|
2902
|
+
readonly status: 507;
|
|
2903
|
+
readonly data: z.ZodObject<{
|
|
2904
|
+
availableBytes: z.ZodInt;
|
|
2905
|
+
reserveBytes: z.ZodInt;
|
|
2906
|
+
requestedBytes: z.ZodInt;
|
|
2907
|
+
}, z.core.$strip>;
|
|
2908
|
+
};
|
|
2406
2909
|
AGENT_OUTDATED: {
|
|
2407
2910
|
readonly message: "The imp's agent is too old for this";
|
|
2408
2911
|
readonly status: 409;
|
|
@@ -2427,6 +2930,7 @@ declare const impContract: {
|
|
|
2427
2930
|
imp: "imp";
|
|
2428
2931
|
secret: "secret";
|
|
2429
2932
|
session: "session";
|
|
2933
|
+
token: "token";
|
|
2430
2934
|
}>;
|
|
2431
2935
|
name: z.ZodString;
|
|
2432
2936
|
}, z.core.$strip>;
|
|
@@ -2442,6 +2946,7 @@ declare const impContract: {
|
|
|
2442
2946
|
imp: "imp";
|
|
2443
2947
|
secret: "secret";
|
|
2444
2948
|
session: "session";
|
|
2949
|
+
token: "token";
|
|
2445
2950
|
}>;
|
|
2446
2951
|
name: z.ZodString;
|
|
2447
2952
|
}, z.core.$strip>;
|
|
@@ -2484,6 +2989,15 @@ declare const impContract: {
|
|
|
2484
2989
|
}>>;
|
|
2485
2990
|
}, z.core.$strip>;
|
|
2486
2991
|
};
|
|
2992
|
+
DISK_FULL: {
|
|
2993
|
+
readonly message: "Not enough free disk on the host";
|
|
2994
|
+
readonly status: 507;
|
|
2995
|
+
readonly data: z.ZodObject<{
|
|
2996
|
+
availableBytes: z.ZodInt;
|
|
2997
|
+
reserveBytes: z.ZodInt;
|
|
2998
|
+
requestedBytes: z.ZodInt;
|
|
2999
|
+
}, z.core.$strip>;
|
|
3000
|
+
};
|
|
2487
3001
|
AGENT_OUTDATED: {
|
|
2488
3002
|
readonly message: "The imp's agent is too old for this";
|
|
2489
3003
|
readonly status: 409;
|
|
@@ -2521,6 +3035,7 @@ declare const impContract: {
|
|
|
2521
3035
|
imp: "imp";
|
|
2522
3036
|
secret: "secret";
|
|
2523
3037
|
session: "session";
|
|
3038
|
+
token: "token";
|
|
2524
3039
|
}>;
|
|
2525
3040
|
name: z.ZodString;
|
|
2526
3041
|
}, z.core.$strip>;
|
|
@@ -2536,6 +3051,7 @@ declare const impContract: {
|
|
|
2536
3051
|
imp: "imp";
|
|
2537
3052
|
secret: "secret";
|
|
2538
3053
|
session: "session";
|
|
3054
|
+
token: "token";
|
|
2539
3055
|
}>;
|
|
2540
3056
|
name: z.ZodString;
|
|
2541
3057
|
}, z.core.$strip>;
|
|
@@ -2578,6 +3094,15 @@ declare const impContract: {
|
|
|
2578
3094
|
}>>;
|
|
2579
3095
|
}, z.core.$strip>;
|
|
2580
3096
|
};
|
|
3097
|
+
DISK_FULL: {
|
|
3098
|
+
readonly message: "Not enough free disk on the host";
|
|
3099
|
+
readonly status: 507;
|
|
3100
|
+
readonly data: z.ZodObject<{
|
|
3101
|
+
availableBytes: z.ZodInt;
|
|
3102
|
+
reserveBytes: z.ZodInt;
|
|
3103
|
+
requestedBytes: z.ZodInt;
|
|
3104
|
+
}, z.core.$strip>;
|
|
3105
|
+
};
|
|
2581
3106
|
AGENT_OUTDATED: {
|
|
2582
3107
|
readonly message: "The imp's agent is too old for this";
|
|
2583
3108
|
readonly status: 409;
|
|
@@ -2598,6 +3123,7 @@ declare const impContract: {
|
|
|
2598
3123
|
imp: "imp";
|
|
2599
3124
|
secret: "secret";
|
|
2600
3125
|
session: "session";
|
|
3126
|
+
token: "token";
|
|
2601
3127
|
}>;
|
|
2602
3128
|
name: z.ZodString;
|
|
2603
3129
|
}, z.core.$strip>;
|
|
@@ -2613,6 +3139,7 @@ declare const impContract: {
|
|
|
2613
3139
|
imp: "imp";
|
|
2614
3140
|
secret: "secret";
|
|
2615
3141
|
session: "session";
|
|
3142
|
+
token: "token";
|
|
2616
3143
|
}>;
|
|
2617
3144
|
name: z.ZodString;
|
|
2618
3145
|
}, z.core.$strip>;
|
|
@@ -2655,6 +3182,15 @@ declare const impContract: {
|
|
|
2655
3182
|
}>>;
|
|
2656
3183
|
}, z.core.$strip>;
|
|
2657
3184
|
};
|
|
3185
|
+
DISK_FULL: {
|
|
3186
|
+
readonly message: "Not enough free disk on the host";
|
|
3187
|
+
readonly status: 507;
|
|
3188
|
+
readonly data: z.ZodObject<{
|
|
3189
|
+
availableBytes: z.ZodInt;
|
|
3190
|
+
reserveBytes: z.ZodInt;
|
|
3191
|
+
requestedBytes: z.ZodInt;
|
|
3192
|
+
}, z.core.$strip>;
|
|
3193
|
+
};
|
|
2658
3194
|
AGENT_OUTDATED: {
|
|
2659
3195
|
readonly message: "The imp's agent is too old for this";
|
|
2660
3196
|
readonly status: 409;
|
|
@@ -2714,6 +3250,7 @@ declare const impContract: {
|
|
|
2714
3250
|
imp: "imp";
|
|
2715
3251
|
secret: "secret";
|
|
2716
3252
|
session: "session";
|
|
3253
|
+
token: "token";
|
|
2717
3254
|
}>;
|
|
2718
3255
|
name: z.ZodString;
|
|
2719
3256
|
}, z.core.$strip>;
|
|
@@ -2729,6 +3266,7 @@ declare const impContract: {
|
|
|
2729
3266
|
imp: "imp";
|
|
2730
3267
|
secret: "secret";
|
|
2731
3268
|
session: "session";
|
|
3269
|
+
token: "token";
|
|
2732
3270
|
}>;
|
|
2733
3271
|
name: z.ZodString;
|
|
2734
3272
|
}, z.core.$strip>;
|
|
@@ -2771,6 +3309,15 @@ declare const impContract: {
|
|
|
2771
3309
|
}>>;
|
|
2772
3310
|
}, z.core.$strip>;
|
|
2773
3311
|
};
|
|
3312
|
+
DISK_FULL: {
|
|
3313
|
+
readonly message: "Not enough free disk on the host";
|
|
3314
|
+
readonly status: 507;
|
|
3315
|
+
readonly data: z.ZodObject<{
|
|
3316
|
+
availableBytes: z.ZodInt;
|
|
3317
|
+
reserveBytes: z.ZodInt;
|
|
3318
|
+
requestedBytes: z.ZodInt;
|
|
3319
|
+
}, z.core.$strip>;
|
|
3320
|
+
};
|
|
2774
3321
|
AGENT_OUTDATED: {
|
|
2775
3322
|
readonly message: "The imp's agent is too old for this";
|
|
2776
3323
|
readonly status: 409;
|
|
@@ -2808,6 +3355,7 @@ declare const impContract: {
|
|
|
2808
3355
|
imp: "imp";
|
|
2809
3356
|
secret: "secret";
|
|
2810
3357
|
session: "session";
|
|
3358
|
+
token: "token";
|
|
2811
3359
|
}>;
|
|
2812
3360
|
name: z.ZodString;
|
|
2813
3361
|
}, z.core.$strip>;
|
|
@@ -2823,6 +3371,7 @@ declare const impContract: {
|
|
|
2823
3371
|
imp: "imp";
|
|
2824
3372
|
secret: "secret";
|
|
2825
3373
|
session: "session";
|
|
3374
|
+
token: "token";
|
|
2826
3375
|
}>;
|
|
2827
3376
|
name: z.ZodString;
|
|
2828
3377
|
}, z.core.$strip>;
|
|
@@ -2865,6 +3414,15 @@ declare const impContract: {
|
|
|
2865
3414
|
}>>;
|
|
2866
3415
|
}, z.core.$strip>;
|
|
2867
3416
|
};
|
|
3417
|
+
DISK_FULL: {
|
|
3418
|
+
readonly message: "Not enough free disk on the host";
|
|
3419
|
+
readonly status: 507;
|
|
3420
|
+
readonly data: z.ZodObject<{
|
|
3421
|
+
availableBytes: z.ZodInt;
|
|
3422
|
+
reserveBytes: z.ZodInt;
|
|
3423
|
+
requestedBytes: z.ZodInt;
|
|
3424
|
+
}, z.core.$strip>;
|
|
3425
|
+
};
|
|
2868
3426
|
AGENT_OUTDATED: {
|
|
2869
3427
|
readonly message: "The imp's agent is too old for this";
|
|
2870
3428
|
readonly status: 409;
|
|
@@ -2884,6 +3442,7 @@ declare const impContract: {
|
|
|
2884
3442
|
imp: "imp";
|
|
2885
3443
|
secret: "secret";
|
|
2886
3444
|
session: "session";
|
|
3445
|
+
token: "token";
|
|
2887
3446
|
}>;
|
|
2888
3447
|
name: z.ZodString;
|
|
2889
3448
|
}, z.core.$strip>;
|
|
@@ -2899,6 +3458,7 @@ declare const impContract: {
|
|
|
2899
3458
|
imp: "imp";
|
|
2900
3459
|
secret: "secret";
|
|
2901
3460
|
session: "session";
|
|
3461
|
+
token: "token";
|
|
2902
3462
|
}>;
|
|
2903
3463
|
name: z.ZodString;
|
|
2904
3464
|
}, z.core.$strip>;
|
|
@@ -2941,6 +3501,15 @@ declare const impContract: {
|
|
|
2941
3501
|
}>>;
|
|
2942
3502
|
}, z.core.$strip>;
|
|
2943
3503
|
};
|
|
3504
|
+
DISK_FULL: {
|
|
3505
|
+
readonly message: "Not enough free disk on the host";
|
|
3506
|
+
readonly status: 507;
|
|
3507
|
+
readonly data: z.ZodObject<{
|
|
3508
|
+
availableBytes: z.ZodInt;
|
|
3509
|
+
reserveBytes: z.ZodInt;
|
|
3510
|
+
requestedBytes: z.ZodInt;
|
|
3511
|
+
}, z.core.$strip>;
|
|
3512
|
+
};
|
|
2944
3513
|
AGENT_OUTDATED: {
|
|
2945
3514
|
readonly message: "The imp's agent is too old for this";
|
|
2946
3515
|
readonly status: 409;
|
|
@@ -2963,6 +3532,7 @@ declare const impContract: {
|
|
|
2963
3532
|
imp: "imp";
|
|
2964
3533
|
secret: "secret";
|
|
2965
3534
|
session: "session";
|
|
3535
|
+
token: "token";
|
|
2966
3536
|
}>;
|
|
2967
3537
|
name: z.ZodString;
|
|
2968
3538
|
}, z.core.$strip>;
|
|
@@ -2978,6 +3548,7 @@ declare const impContract: {
|
|
|
2978
3548
|
imp: "imp";
|
|
2979
3549
|
secret: "secret";
|
|
2980
3550
|
session: "session";
|
|
3551
|
+
token: "token";
|
|
2981
3552
|
}>;
|
|
2982
3553
|
name: z.ZodString;
|
|
2983
3554
|
}, z.core.$strip>;
|
|
@@ -3020,6 +3591,15 @@ declare const impContract: {
|
|
|
3020
3591
|
}>>;
|
|
3021
3592
|
}, z.core.$strip>;
|
|
3022
3593
|
};
|
|
3594
|
+
DISK_FULL: {
|
|
3595
|
+
readonly message: "Not enough free disk on the host";
|
|
3596
|
+
readonly status: 507;
|
|
3597
|
+
readonly data: z.ZodObject<{
|
|
3598
|
+
availableBytes: z.ZodInt;
|
|
3599
|
+
reserveBytes: z.ZodInt;
|
|
3600
|
+
requestedBytes: z.ZodInt;
|
|
3601
|
+
}, z.core.$strip>;
|
|
3602
|
+
};
|
|
3023
3603
|
AGENT_OUTDATED: {
|
|
3024
3604
|
readonly message: "The imp's agent is too old for this";
|
|
3025
3605
|
readonly status: 409;
|
|
@@ -3040,6 +3620,7 @@ declare const impContract: {
|
|
|
3040
3620
|
imp: "imp";
|
|
3041
3621
|
secret: "secret";
|
|
3042
3622
|
session: "session";
|
|
3623
|
+
token: "token";
|
|
3043
3624
|
}>;
|
|
3044
3625
|
name: z.ZodString;
|
|
3045
3626
|
}, z.core.$strip>;
|
|
@@ -3055,6 +3636,7 @@ declare const impContract: {
|
|
|
3055
3636
|
imp: "imp";
|
|
3056
3637
|
secret: "secret";
|
|
3057
3638
|
session: "session";
|
|
3639
|
+
token: "token";
|
|
3058
3640
|
}>;
|
|
3059
3641
|
name: z.ZodString;
|
|
3060
3642
|
}, z.core.$strip>;
|
|
@@ -3097,6 +3679,15 @@ declare const impContract: {
|
|
|
3097
3679
|
}>>;
|
|
3098
3680
|
}, z.core.$strip>;
|
|
3099
3681
|
};
|
|
3682
|
+
DISK_FULL: {
|
|
3683
|
+
readonly message: "Not enough free disk on the host";
|
|
3684
|
+
readonly status: 507;
|
|
3685
|
+
readonly data: z.ZodObject<{
|
|
3686
|
+
availableBytes: z.ZodInt;
|
|
3687
|
+
reserveBytes: z.ZodInt;
|
|
3688
|
+
requestedBytes: z.ZodInt;
|
|
3689
|
+
}, z.core.$strip>;
|
|
3690
|
+
};
|
|
3100
3691
|
AGENT_OUTDATED: {
|
|
3101
3692
|
readonly message: "The imp's agent is too old for this";
|
|
3102
3693
|
readonly status: 409;
|
|
@@ -3116,6 +3707,7 @@ declare const impContract: {
|
|
|
3116
3707
|
imp: "imp";
|
|
3117
3708
|
secret: "secret";
|
|
3118
3709
|
session: "session";
|
|
3710
|
+
token: "token";
|
|
3119
3711
|
}>;
|
|
3120
3712
|
name: z.ZodString;
|
|
3121
3713
|
}, z.core.$strip>;
|
|
@@ -3131,6 +3723,7 @@ declare const impContract: {
|
|
|
3131
3723
|
imp: "imp";
|
|
3132
3724
|
secret: "secret";
|
|
3133
3725
|
session: "session";
|
|
3726
|
+
token: "token";
|
|
3134
3727
|
}>;
|
|
3135
3728
|
name: z.ZodString;
|
|
3136
3729
|
}, z.core.$strip>;
|
|
@@ -3173,6 +3766,15 @@ declare const impContract: {
|
|
|
3173
3766
|
}>>;
|
|
3174
3767
|
}, z.core.$strip>;
|
|
3175
3768
|
};
|
|
3769
|
+
DISK_FULL: {
|
|
3770
|
+
readonly message: "Not enough free disk on the host";
|
|
3771
|
+
readonly status: 507;
|
|
3772
|
+
readonly data: z.ZodObject<{
|
|
3773
|
+
availableBytes: z.ZodInt;
|
|
3774
|
+
reserveBytes: z.ZodInt;
|
|
3775
|
+
requestedBytes: z.ZodInt;
|
|
3776
|
+
}, z.core.$strip>;
|
|
3777
|
+
};
|
|
3176
3778
|
AGENT_OUTDATED: {
|
|
3177
3779
|
readonly message: "The imp's agent is too old for this";
|
|
3178
3780
|
readonly status: 409;
|
|
@@ -3206,6 +3808,7 @@ declare const impContract: {
|
|
|
3206
3808
|
imp: "imp";
|
|
3207
3809
|
secret: "secret";
|
|
3208
3810
|
session: "session";
|
|
3811
|
+
token: "token";
|
|
3209
3812
|
}>;
|
|
3210
3813
|
name: z.ZodString;
|
|
3211
3814
|
}, z.core.$strip>;
|
|
@@ -3221,6 +3824,7 @@ declare const impContract: {
|
|
|
3221
3824
|
imp: "imp";
|
|
3222
3825
|
secret: "secret";
|
|
3223
3826
|
session: "session";
|
|
3827
|
+
token: "token";
|
|
3224
3828
|
}>;
|
|
3225
3829
|
name: z.ZodString;
|
|
3226
3830
|
}, z.core.$strip>;
|
|
@@ -3263,6 +3867,15 @@ declare const impContract: {
|
|
|
3263
3867
|
}>>;
|
|
3264
3868
|
}, z.core.$strip>;
|
|
3265
3869
|
};
|
|
3870
|
+
DISK_FULL: {
|
|
3871
|
+
readonly message: "Not enough free disk on the host";
|
|
3872
|
+
readonly status: 507;
|
|
3873
|
+
readonly data: z.ZodObject<{
|
|
3874
|
+
availableBytes: z.ZodInt;
|
|
3875
|
+
reserveBytes: z.ZodInt;
|
|
3876
|
+
requestedBytes: z.ZodInt;
|
|
3877
|
+
}, z.core.$strip>;
|
|
3878
|
+
};
|
|
3266
3879
|
AGENT_OUTDATED: {
|
|
3267
3880
|
readonly message: "The imp's agent is too old for this";
|
|
3268
3881
|
readonly status: 409;
|
|
@@ -3277,8 +3890,10 @@ declare const impContract: {
|
|
|
3277
3890
|
actor: z.ZodEnum<{
|
|
3278
3891
|
dashboard: "dashboard";
|
|
3279
3892
|
ssh: "ssh";
|
|
3893
|
+
tailnet: "tailnet";
|
|
3280
3894
|
token: "token";
|
|
3281
3895
|
}>;
|
|
3896
|
+
actorName: z.ZodOptional<z.ZodString>;
|
|
3282
3897
|
imp: z.ZodOptional<z.ZodString>;
|
|
3283
3898
|
outcome: z.ZodString;
|
|
3284
3899
|
durationMs: z.ZodInt;
|
|
@@ -3294,6 +3909,7 @@ declare const impContract: {
|
|
|
3294
3909
|
imp: "imp";
|
|
3295
3910
|
secret: "secret";
|
|
3296
3911
|
session: "session";
|
|
3912
|
+
token: "token";
|
|
3297
3913
|
}>;
|
|
3298
3914
|
name: z.ZodString;
|
|
3299
3915
|
}, z.core.$strip>;
|
|
@@ -3309,6 +3925,7 @@ declare const impContract: {
|
|
|
3309
3925
|
imp: "imp";
|
|
3310
3926
|
secret: "secret";
|
|
3311
3927
|
session: "session";
|
|
3928
|
+
token: "token";
|
|
3312
3929
|
}>;
|
|
3313
3930
|
name: z.ZodString;
|
|
3314
3931
|
}, z.core.$strip>;
|
|
@@ -3351,6 +3968,15 @@ declare const impContract: {
|
|
|
3351
3968
|
}>>;
|
|
3352
3969
|
}, z.core.$strip>;
|
|
3353
3970
|
};
|
|
3971
|
+
DISK_FULL: {
|
|
3972
|
+
readonly message: "Not enough free disk on the host";
|
|
3973
|
+
readonly status: 507;
|
|
3974
|
+
readonly data: z.ZodObject<{
|
|
3975
|
+
availableBytes: z.ZodInt;
|
|
3976
|
+
reserveBytes: z.ZodInt;
|
|
3977
|
+
requestedBytes: z.ZodInt;
|
|
3978
|
+
}, z.core.$strip>;
|
|
3979
|
+
};
|
|
3354
3980
|
AGENT_OUTDATED: {
|
|
3355
3981
|
readonly message: "The imp's agent is too old for this";
|
|
3356
3982
|
readonly status: 409;
|
|
@@ -3370,6 +3996,14 @@ declare const impContract: {
|
|
|
3370
3996
|
state: "creating" | "error" | "running" | "sleeping" | "stopped";
|
|
3371
3997
|
vcpus: number;
|
|
3372
3998
|
memoryMib: number;
|
|
3999
|
+
diskMib: number;
|
|
4000
|
+
diskUsage?: {
|
|
4001
|
+
exclusiveBytes: number;
|
|
4002
|
+
sharedBytes: number;
|
|
4003
|
+
measuredAt: Date;
|
|
4004
|
+
isPartial: boolean;
|
|
4005
|
+
isUpperBound: boolean;
|
|
4006
|
+
} | undefined;
|
|
3373
4007
|
ip: string;
|
|
3374
4008
|
slot: number;
|
|
3375
4009
|
port: number;
|
|
@@ -3390,7 +4024,7 @@ declare const impContract: {
|
|
|
3390
4024
|
v: 1;
|
|
3391
4025
|
at: Date;
|
|
3392
4026
|
ev: "ImpChanged";
|
|
3393
|
-
reason: "adopted" | "booted" | "failed" | "held" | "repaired" | "restored" | "slept" | "stopped" | "woke";
|
|
4027
|
+
reason: "adopted" | "booted" | "failed" | "held" | "repaired" | "resized" | "restored" | "slept" | "stopped" | "woke";
|
|
3394
4028
|
imp: {
|
|
3395
4029
|
id: string;
|
|
3396
4030
|
name: string;
|
|
@@ -3398,6 +4032,14 @@ declare const impContract: {
|
|
|
3398
4032
|
state: "creating" | "error" | "running" | "sleeping" | "stopped";
|
|
3399
4033
|
vcpus: number;
|
|
3400
4034
|
memoryMib: number;
|
|
4035
|
+
diskMib: number;
|
|
4036
|
+
diskUsage?: {
|
|
4037
|
+
exclusiveBytes: number;
|
|
4038
|
+
sharedBytes: number;
|
|
4039
|
+
measuredAt: Date;
|
|
4040
|
+
isPartial: boolean;
|
|
4041
|
+
isUpperBound: boolean;
|
|
4042
|
+
} | undefined;
|
|
3401
4043
|
ip: string;
|
|
3402
4044
|
slot: number;
|
|
3403
4045
|
port: number;
|
|
@@ -3431,6 +4073,14 @@ declare const impContract: {
|
|
|
3431
4073
|
state: "creating" | "error" | "running" | "sleeping" | "stopped";
|
|
3432
4074
|
vcpus: number;
|
|
3433
4075
|
memoryMib: number;
|
|
4076
|
+
diskMib: number;
|
|
4077
|
+
diskUsage?: {
|
|
4078
|
+
exclusiveBytes: number;
|
|
4079
|
+
sharedBytes: number;
|
|
4080
|
+
measuredAt: Date;
|
|
4081
|
+
isPartial: boolean;
|
|
4082
|
+
isUpperBound: boolean;
|
|
4083
|
+
} | undefined;
|
|
3434
4084
|
ip: string;
|
|
3435
4085
|
slot: number;
|
|
3436
4086
|
port: number;
|
|
@@ -3457,6 +4107,7 @@ declare const impContract: {
|
|
|
3457
4107
|
label?: string | undefined;
|
|
3458
4108
|
createdAt: Date;
|
|
3459
4109
|
sizeBytes?: number | undefined;
|
|
4110
|
+
diskMib: number;
|
|
3460
4111
|
};
|
|
3461
4112
|
} | {
|
|
3462
4113
|
v: 1;
|
|
@@ -3468,6 +4119,7 @@ declare const impContract: {
|
|
|
3468
4119
|
label?: string | undefined;
|
|
3469
4120
|
createdAt: Date;
|
|
3470
4121
|
sizeBytes?: number | undefined;
|
|
4122
|
+
diskMib: number;
|
|
3471
4123
|
};
|
|
3472
4124
|
} | {
|
|
3473
4125
|
v: 1;
|
|
@@ -3491,6 +4143,14 @@ declare const impContract: {
|
|
|
3491
4143
|
state: "creating" | "error" | "running" | "sleeping" | "stopped";
|
|
3492
4144
|
vcpus: number;
|
|
3493
4145
|
memoryMib: number;
|
|
4146
|
+
diskMib: number;
|
|
4147
|
+
diskUsage?: {
|
|
4148
|
+
exclusiveBytes: number;
|
|
4149
|
+
sharedBytes: number;
|
|
4150
|
+
measuredAt: Date;
|
|
4151
|
+
isPartial: boolean;
|
|
4152
|
+
isUpperBound: boolean;
|
|
4153
|
+
} | undefined;
|
|
3494
4154
|
ip: string;
|
|
3495
4155
|
slot: number;
|
|
3496
4156
|
port: number;
|
|
@@ -3511,7 +4171,7 @@ declare const impContract: {
|
|
|
3511
4171
|
v: 1;
|
|
3512
4172
|
at: Date;
|
|
3513
4173
|
ev: "ImpChanged";
|
|
3514
|
-
reason: "adopted" | "booted" | "failed" | "held" | "repaired" | "restored" | "slept" | "stopped" | "woke";
|
|
4174
|
+
reason: "adopted" | "booted" | "failed" | "held" | "repaired" | "resized" | "restored" | "slept" | "stopped" | "woke";
|
|
3515
4175
|
imp: {
|
|
3516
4176
|
id: string;
|
|
3517
4177
|
name: string;
|
|
@@ -3519,6 +4179,14 @@ declare const impContract: {
|
|
|
3519
4179
|
state: "creating" | "error" | "running" | "sleeping" | "stopped";
|
|
3520
4180
|
vcpus: number;
|
|
3521
4181
|
memoryMib: number;
|
|
4182
|
+
diskMib: number;
|
|
4183
|
+
diskUsage?: {
|
|
4184
|
+
exclusiveBytes: number;
|
|
4185
|
+
sharedBytes: number;
|
|
4186
|
+
measuredAt: Date;
|
|
4187
|
+
isPartial: boolean;
|
|
4188
|
+
isUpperBound: boolean;
|
|
4189
|
+
} | undefined;
|
|
3522
4190
|
ip: string;
|
|
3523
4191
|
slot: number;
|
|
3524
4192
|
port: number;
|
|
@@ -3552,6 +4220,14 @@ declare const impContract: {
|
|
|
3552
4220
|
state: "creating" | "error" | "running" | "sleeping" | "stopped";
|
|
3553
4221
|
vcpus: number;
|
|
3554
4222
|
memoryMib: number;
|
|
4223
|
+
diskMib: number;
|
|
4224
|
+
diskUsage?: {
|
|
4225
|
+
exclusiveBytes: number;
|
|
4226
|
+
sharedBytes: number;
|
|
4227
|
+
measuredAt: Date;
|
|
4228
|
+
isPartial: boolean;
|
|
4229
|
+
isUpperBound: boolean;
|
|
4230
|
+
} | undefined;
|
|
3555
4231
|
ip: string;
|
|
3556
4232
|
slot: number;
|
|
3557
4233
|
port: number;
|
|
@@ -3578,6 +4254,7 @@ declare const impContract: {
|
|
|
3578
4254
|
label?: string | undefined;
|
|
3579
4255
|
createdAt: Date;
|
|
3580
4256
|
sizeBytes?: number | undefined;
|
|
4257
|
+
diskMib: number;
|
|
3581
4258
|
};
|
|
3582
4259
|
} | {
|
|
3583
4260
|
v: 1;
|
|
@@ -3589,6 +4266,7 @@ declare const impContract: {
|
|
|
3589
4266
|
label?: string | undefined;
|
|
3590
4267
|
createdAt: Date;
|
|
3591
4268
|
sizeBytes?: number | undefined;
|
|
4269
|
+
diskMib: number;
|
|
3592
4270
|
};
|
|
3593
4271
|
} | {
|
|
3594
4272
|
v: 1;
|
|
@@ -3612,6 +4290,7 @@ declare const impContract: {
|
|
|
3612
4290
|
imp: "imp";
|
|
3613
4291
|
secret: "secret";
|
|
3614
4292
|
session: "session";
|
|
4293
|
+
token: "token";
|
|
3615
4294
|
}>;
|
|
3616
4295
|
name: z.ZodString;
|
|
3617
4296
|
}, z.core.$strip>;
|
|
@@ -3627,6 +4306,7 @@ declare const impContract: {
|
|
|
3627
4306
|
imp: "imp";
|
|
3628
4307
|
secret: "secret";
|
|
3629
4308
|
session: "session";
|
|
4309
|
+
token: "token";
|
|
3630
4310
|
}>;
|
|
3631
4311
|
name: z.ZodString;
|
|
3632
4312
|
}, z.core.$strip>;
|
|
@@ -3669,6 +4349,15 @@ declare const impContract: {
|
|
|
3669
4349
|
}>>;
|
|
3670
4350
|
}, z.core.$strip>;
|
|
3671
4351
|
};
|
|
4352
|
+
DISK_FULL: {
|
|
4353
|
+
readonly message: "Not enough free disk on the host";
|
|
4354
|
+
readonly status: 507;
|
|
4355
|
+
readonly data: z.ZodObject<{
|
|
4356
|
+
availableBytes: z.ZodInt;
|
|
4357
|
+
reserveBytes: z.ZodInt;
|
|
4358
|
+
requestedBytes: z.ZodInt;
|
|
4359
|
+
}, z.core.$strip>;
|
|
4360
|
+
};
|
|
3672
4361
|
AGENT_OUTDATED: {
|
|
3673
4362
|
readonly message: "The imp's agent is too old for this";
|
|
3674
4363
|
readonly status: 409;
|
|
@@ -3708,6 +4397,10 @@ declare const impContract: {
|
|
|
3708
4397
|
}>;
|
|
3709
4398
|
usedBytes: z.ZodInt;
|
|
3710
4399
|
availableBytes: z.ZodInt;
|
|
4400
|
+
reserveBytes: z.ZodInt;
|
|
4401
|
+
pendingBytes: z.ZodInt;
|
|
4402
|
+
isLow: z.ZodBoolean;
|
|
4403
|
+
impDiskBytes: z.ZodInt;
|
|
3711
4404
|
}, z.core.$strip>;
|
|
3712
4405
|
tailscale: z.ZodObject<{
|
|
3713
4406
|
enabled: z.ZodBoolean;
|
|
@@ -3727,6 +4420,7 @@ declare const impContract: {
|
|
|
3727
4420
|
imp: "imp";
|
|
3728
4421
|
secret: "secret";
|
|
3729
4422
|
session: "session";
|
|
4423
|
+
token: "token";
|
|
3730
4424
|
}>;
|
|
3731
4425
|
name: z.ZodString;
|
|
3732
4426
|
}, z.core.$strip>;
|
|
@@ -3742,6 +4436,7 @@ declare const impContract: {
|
|
|
3742
4436
|
imp: "imp";
|
|
3743
4437
|
secret: "secret";
|
|
3744
4438
|
session: "session";
|
|
4439
|
+
token: "token";
|
|
3745
4440
|
}>;
|
|
3746
4441
|
name: z.ZodString;
|
|
3747
4442
|
}, z.core.$strip>;
|
|
@@ -3784,37 +4479,540 @@ declare const impContract: {
|
|
|
3784
4479
|
}>>;
|
|
3785
4480
|
}, z.core.$strip>;
|
|
3786
4481
|
};
|
|
4482
|
+
DISK_FULL: {
|
|
4483
|
+
readonly message: "Not enough free disk on the host";
|
|
4484
|
+
readonly status: 507;
|
|
4485
|
+
readonly data: z.ZodObject<{
|
|
4486
|
+
availableBytes: z.ZodInt;
|
|
4487
|
+
reserveBytes: z.ZodInt;
|
|
4488
|
+
requestedBytes: z.ZodInt;
|
|
4489
|
+
}, z.core.$strip>;
|
|
4490
|
+
};
|
|
3787
4491
|
AGENT_OUTDATED: {
|
|
3788
4492
|
readonly message: "The imp's agent is too old for this";
|
|
3789
4493
|
readonly status: 409;
|
|
3790
4494
|
};
|
|
3791
4495
|
}>, Record<never, never>>;
|
|
3792
|
-
|
|
3793
|
-
|
|
3794
|
-
|
|
3795
|
-
|
|
3796
|
-
|
|
3797
|
-
|
|
3798
|
-
|
|
3799
|
-
|
|
3800
|
-
|
|
3801
|
-
|
|
3802
|
-
|
|
3803
|
-
}>;
|
|
3804
|
-
|
|
3805
|
-
|
|
3806
|
-
|
|
3807
|
-
|
|
3808
|
-
|
|
3809
|
-
|
|
3810
|
-
|
|
3811
|
-
|
|
3812
|
-
|
|
3813
|
-
|
|
3814
|
-
|
|
3815
|
-
|
|
3816
|
-
|
|
3817
|
-
|
|
4496
|
+
gc: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
4497
|
+
dryRun: z.ZodOptional<z.ZodBoolean>;
|
|
4498
|
+
}, z.core.$strip>, z.ZodReadonly<z.ZodObject<{
|
|
4499
|
+
dryRun: z.ZodBoolean;
|
|
4500
|
+
dropped: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
|
|
4501
|
+
kind: z.ZodEnum<{
|
|
4502
|
+
checkpoint: "checkpoint";
|
|
4503
|
+
image: "image";
|
|
4504
|
+
imp: "imp";
|
|
4505
|
+
memory: "memory";
|
|
4506
|
+
snapshot: "snapshot";
|
|
4507
|
+
}>;
|
|
4508
|
+
id: z.ZodString;
|
|
4509
|
+
}, z.core.$strip>>>>;
|
|
4510
|
+
}, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
4511
|
+
NOT_FOUND: {
|
|
4512
|
+
readonly message: "Not found";
|
|
4513
|
+
readonly data: z.ZodObject<{
|
|
4514
|
+
kind: z.ZodEnum<{
|
|
4515
|
+
backup: "backup";
|
|
4516
|
+
checkpoint: "checkpoint";
|
|
4517
|
+
grant: "grant";
|
|
4518
|
+
image: "image";
|
|
4519
|
+
imp: "imp";
|
|
4520
|
+
secret: "secret";
|
|
4521
|
+
session: "session";
|
|
4522
|
+
token: "token";
|
|
4523
|
+
}>;
|
|
4524
|
+
name: z.ZodString;
|
|
4525
|
+
}, z.core.$strip>;
|
|
4526
|
+
};
|
|
4527
|
+
CONFLICT: {
|
|
4528
|
+
readonly message: "Already exists";
|
|
4529
|
+
readonly data: z.ZodObject<{
|
|
4530
|
+
kind: z.ZodEnum<{
|
|
4531
|
+
backup: "backup";
|
|
4532
|
+
checkpoint: "checkpoint";
|
|
4533
|
+
grant: "grant";
|
|
4534
|
+
image: "image";
|
|
4535
|
+
imp: "imp";
|
|
4536
|
+
secret: "secret";
|
|
4537
|
+
session: "session";
|
|
4538
|
+
token: "token";
|
|
4539
|
+
}>;
|
|
4540
|
+
name: z.ZodString;
|
|
4541
|
+
}, z.core.$strip>;
|
|
4542
|
+
};
|
|
4543
|
+
FORBIDDEN: {
|
|
4544
|
+
readonly message: "Not allowed";
|
|
4545
|
+
};
|
|
4546
|
+
PRECONDITION_FAILED: {
|
|
4547
|
+
readonly message: "Not possible on this host";
|
|
4548
|
+
};
|
|
4549
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4550
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4551
|
+
readonly status: 503;
|
|
4552
|
+
readonly data: z.ZodObject<{
|
|
4553
|
+
budgetMib: z.ZodInt;
|
|
4554
|
+
usedMib: z.ZodInt;
|
|
4555
|
+
requestedMib: z.ZodInt;
|
|
4556
|
+
}, z.core.$strip>;
|
|
4557
|
+
};
|
|
4558
|
+
SERVICE_UNAVAILABLE: {
|
|
4559
|
+
readonly message: "impd is stopping";
|
|
4560
|
+
};
|
|
4561
|
+
INVALID_STATE: {
|
|
4562
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4563
|
+
readonly status: 409;
|
|
4564
|
+
readonly data: z.ZodObject<{
|
|
4565
|
+
state: z.ZodEnum<{
|
|
4566
|
+
creating: "creating";
|
|
4567
|
+
error: "error";
|
|
4568
|
+
running: "running";
|
|
4569
|
+
sleeping: "sleeping";
|
|
4570
|
+
stopped: "stopped";
|
|
4571
|
+
}>;
|
|
4572
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4573
|
+
creating: "creating";
|
|
4574
|
+
error: "error";
|
|
4575
|
+
running: "running";
|
|
4576
|
+
sleeping: "sleeping";
|
|
4577
|
+
stopped: "stopped";
|
|
4578
|
+
}>>;
|
|
4579
|
+
}, z.core.$strip>;
|
|
4580
|
+
};
|
|
4581
|
+
DISK_FULL: {
|
|
4582
|
+
readonly message: "Not enough free disk on the host";
|
|
4583
|
+
readonly status: 507;
|
|
4584
|
+
readonly data: z.ZodObject<{
|
|
4585
|
+
availableBytes: z.ZodInt;
|
|
4586
|
+
reserveBytes: z.ZodInt;
|
|
4587
|
+
requestedBytes: z.ZodInt;
|
|
4588
|
+
}, z.core.$strip>;
|
|
4589
|
+
};
|
|
4590
|
+
AGENT_OUTDATED: {
|
|
4591
|
+
readonly message: "The imp's agent is too old for this";
|
|
4592
|
+
readonly status: 409;
|
|
4593
|
+
};
|
|
4594
|
+
}>, Record<never, never>>;
|
|
4595
|
+
};
|
|
4596
|
+
tokens: {
|
|
4597
|
+
list: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodArray<z.ZodObject<{
|
|
4598
|
+
name: z.ZodString;
|
|
4599
|
+
scope: z.ZodEnum<{
|
|
4600
|
+
exec: "exec";
|
|
4601
|
+
manage: "manage";
|
|
4602
|
+
read: "read";
|
|
4603
|
+
}>;
|
|
4604
|
+
imps: z.ZodNullable<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
|
|
4605
|
+
createdAt: z.ZodDate;
|
|
4606
|
+
}, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
4607
|
+
NOT_FOUND: {
|
|
4608
|
+
readonly message: "Not found";
|
|
4609
|
+
readonly data: z.ZodObject<{
|
|
4610
|
+
kind: z.ZodEnum<{
|
|
4611
|
+
backup: "backup";
|
|
4612
|
+
checkpoint: "checkpoint";
|
|
4613
|
+
grant: "grant";
|
|
4614
|
+
image: "image";
|
|
4615
|
+
imp: "imp";
|
|
4616
|
+
secret: "secret";
|
|
4617
|
+
session: "session";
|
|
4618
|
+
token: "token";
|
|
4619
|
+
}>;
|
|
4620
|
+
name: z.ZodString;
|
|
4621
|
+
}, z.core.$strip>;
|
|
4622
|
+
};
|
|
4623
|
+
CONFLICT: {
|
|
4624
|
+
readonly message: "Already exists";
|
|
4625
|
+
readonly data: z.ZodObject<{
|
|
4626
|
+
kind: z.ZodEnum<{
|
|
4627
|
+
backup: "backup";
|
|
4628
|
+
checkpoint: "checkpoint";
|
|
4629
|
+
grant: "grant";
|
|
4630
|
+
image: "image";
|
|
4631
|
+
imp: "imp";
|
|
4632
|
+
secret: "secret";
|
|
4633
|
+
session: "session";
|
|
4634
|
+
token: "token";
|
|
4635
|
+
}>;
|
|
4636
|
+
name: z.ZodString;
|
|
4637
|
+
}, z.core.$strip>;
|
|
4638
|
+
};
|
|
4639
|
+
FORBIDDEN: {
|
|
4640
|
+
readonly message: "Not allowed";
|
|
4641
|
+
};
|
|
4642
|
+
PRECONDITION_FAILED: {
|
|
4643
|
+
readonly message: "Not possible on this host";
|
|
4644
|
+
};
|
|
4645
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4646
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4647
|
+
readonly status: 503;
|
|
4648
|
+
readonly data: z.ZodObject<{
|
|
4649
|
+
budgetMib: z.ZodInt;
|
|
4650
|
+
usedMib: z.ZodInt;
|
|
4651
|
+
requestedMib: z.ZodInt;
|
|
4652
|
+
}, z.core.$strip>;
|
|
4653
|
+
};
|
|
4654
|
+
SERVICE_UNAVAILABLE: {
|
|
4655
|
+
readonly message: "impd is stopping";
|
|
4656
|
+
};
|
|
4657
|
+
INVALID_STATE: {
|
|
4658
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4659
|
+
readonly status: 409;
|
|
4660
|
+
readonly data: z.ZodObject<{
|
|
4661
|
+
state: z.ZodEnum<{
|
|
4662
|
+
creating: "creating";
|
|
4663
|
+
error: "error";
|
|
4664
|
+
running: "running";
|
|
4665
|
+
sleeping: "sleeping";
|
|
4666
|
+
stopped: "stopped";
|
|
4667
|
+
}>;
|
|
4668
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4669
|
+
creating: "creating";
|
|
4670
|
+
error: "error";
|
|
4671
|
+
running: "running";
|
|
4672
|
+
sleeping: "sleeping";
|
|
4673
|
+
stopped: "stopped";
|
|
4674
|
+
}>>;
|
|
4675
|
+
}, z.core.$strip>;
|
|
4676
|
+
};
|
|
4677
|
+
DISK_FULL: {
|
|
4678
|
+
readonly message: "Not enough free disk on the host";
|
|
4679
|
+
readonly status: 507;
|
|
4680
|
+
readonly data: z.ZodObject<{
|
|
4681
|
+
availableBytes: z.ZodInt;
|
|
4682
|
+
reserveBytes: z.ZodInt;
|
|
4683
|
+
requestedBytes: z.ZodInt;
|
|
4684
|
+
}, z.core.$strip>;
|
|
4685
|
+
};
|
|
4686
|
+
AGENT_OUTDATED: {
|
|
4687
|
+
readonly message: "The imp's agent is too old for this";
|
|
4688
|
+
readonly status: 409;
|
|
4689
|
+
};
|
|
4690
|
+
}>, Record<never, never>>;
|
|
4691
|
+
create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
4692
|
+
name: z.ZodString;
|
|
4693
|
+
scope: z.ZodEnum<{
|
|
4694
|
+
exec: "exec";
|
|
4695
|
+
manage: "manage";
|
|
4696
|
+
read: "read";
|
|
4697
|
+
}>;
|
|
4698
|
+
imps: z.ZodOptional<z.ZodArray<z.ZodString>>;
|
|
4699
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4700
|
+
token: z.ZodObject<{
|
|
4701
|
+
name: z.ZodString;
|
|
4702
|
+
scope: z.ZodEnum<{
|
|
4703
|
+
exec: "exec";
|
|
4704
|
+
manage: "manage";
|
|
4705
|
+
read: "read";
|
|
4706
|
+
}>;
|
|
4707
|
+
imps: z.ZodNullable<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
|
|
4708
|
+
createdAt: z.ZodDate;
|
|
4709
|
+
}, z.core.$strip>;
|
|
4710
|
+
secret: z.ZodString;
|
|
4711
|
+
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
4712
|
+
NOT_FOUND: {
|
|
4713
|
+
readonly message: "Not found";
|
|
4714
|
+
readonly data: z.ZodObject<{
|
|
4715
|
+
kind: z.ZodEnum<{
|
|
4716
|
+
backup: "backup";
|
|
4717
|
+
checkpoint: "checkpoint";
|
|
4718
|
+
grant: "grant";
|
|
4719
|
+
image: "image";
|
|
4720
|
+
imp: "imp";
|
|
4721
|
+
secret: "secret";
|
|
4722
|
+
session: "session";
|
|
4723
|
+
token: "token";
|
|
4724
|
+
}>;
|
|
4725
|
+
name: z.ZodString;
|
|
4726
|
+
}, z.core.$strip>;
|
|
4727
|
+
};
|
|
4728
|
+
CONFLICT: {
|
|
4729
|
+
readonly message: "Already exists";
|
|
4730
|
+
readonly data: z.ZodObject<{
|
|
4731
|
+
kind: z.ZodEnum<{
|
|
4732
|
+
backup: "backup";
|
|
4733
|
+
checkpoint: "checkpoint";
|
|
4734
|
+
grant: "grant";
|
|
4735
|
+
image: "image";
|
|
4736
|
+
imp: "imp";
|
|
4737
|
+
secret: "secret";
|
|
4738
|
+
session: "session";
|
|
4739
|
+
token: "token";
|
|
4740
|
+
}>;
|
|
4741
|
+
name: z.ZodString;
|
|
4742
|
+
}, z.core.$strip>;
|
|
4743
|
+
};
|
|
4744
|
+
FORBIDDEN: {
|
|
4745
|
+
readonly message: "Not allowed";
|
|
4746
|
+
};
|
|
4747
|
+
PRECONDITION_FAILED: {
|
|
4748
|
+
readonly message: "Not possible on this host";
|
|
4749
|
+
};
|
|
4750
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4751
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4752
|
+
readonly status: 503;
|
|
4753
|
+
readonly data: z.ZodObject<{
|
|
4754
|
+
budgetMib: z.ZodInt;
|
|
4755
|
+
usedMib: z.ZodInt;
|
|
4756
|
+
requestedMib: z.ZodInt;
|
|
4757
|
+
}, z.core.$strip>;
|
|
4758
|
+
};
|
|
4759
|
+
SERVICE_UNAVAILABLE: {
|
|
4760
|
+
readonly message: "impd is stopping";
|
|
4761
|
+
};
|
|
4762
|
+
INVALID_STATE: {
|
|
4763
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4764
|
+
readonly status: 409;
|
|
4765
|
+
readonly data: z.ZodObject<{
|
|
4766
|
+
state: z.ZodEnum<{
|
|
4767
|
+
creating: "creating";
|
|
4768
|
+
error: "error";
|
|
4769
|
+
running: "running";
|
|
4770
|
+
sleeping: "sleeping";
|
|
4771
|
+
stopped: "stopped";
|
|
4772
|
+
}>;
|
|
4773
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4774
|
+
creating: "creating";
|
|
4775
|
+
error: "error";
|
|
4776
|
+
running: "running";
|
|
4777
|
+
sleeping: "sleeping";
|
|
4778
|
+
stopped: "stopped";
|
|
4779
|
+
}>>;
|
|
4780
|
+
}, z.core.$strip>;
|
|
4781
|
+
};
|
|
4782
|
+
DISK_FULL: {
|
|
4783
|
+
readonly message: "Not enough free disk on the host";
|
|
4784
|
+
readonly status: 507;
|
|
4785
|
+
readonly data: z.ZodObject<{
|
|
4786
|
+
availableBytes: z.ZodInt;
|
|
4787
|
+
reserveBytes: z.ZodInt;
|
|
4788
|
+
requestedBytes: z.ZodInt;
|
|
4789
|
+
}, z.core.$strip>;
|
|
4790
|
+
};
|
|
4791
|
+
AGENT_OUTDATED: {
|
|
4792
|
+
readonly message: "The imp's agent is too old for this";
|
|
4793
|
+
readonly status: 409;
|
|
4794
|
+
};
|
|
4795
|
+
}>, Record<never, never>>;
|
|
4796
|
+
delete: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
4797
|
+
name: z.ZodString;
|
|
4798
|
+
}, z.core.$strip>, z.ZodObject<{}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
4799
|
+
NOT_FOUND: {
|
|
4800
|
+
readonly message: "Not found";
|
|
4801
|
+
readonly data: z.ZodObject<{
|
|
4802
|
+
kind: z.ZodEnum<{
|
|
4803
|
+
backup: "backup";
|
|
4804
|
+
checkpoint: "checkpoint";
|
|
4805
|
+
grant: "grant";
|
|
4806
|
+
image: "image";
|
|
4807
|
+
imp: "imp";
|
|
4808
|
+
secret: "secret";
|
|
4809
|
+
session: "session";
|
|
4810
|
+
token: "token";
|
|
4811
|
+
}>;
|
|
4812
|
+
name: z.ZodString;
|
|
4813
|
+
}, z.core.$strip>;
|
|
4814
|
+
};
|
|
4815
|
+
CONFLICT: {
|
|
4816
|
+
readonly message: "Already exists";
|
|
4817
|
+
readonly data: z.ZodObject<{
|
|
4818
|
+
kind: z.ZodEnum<{
|
|
4819
|
+
backup: "backup";
|
|
4820
|
+
checkpoint: "checkpoint";
|
|
4821
|
+
grant: "grant";
|
|
4822
|
+
image: "image";
|
|
4823
|
+
imp: "imp";
|
|
4824
|
+
secret: "secret";
|
|
4825
|
+
session: "session";
|
|
4826
|
+
token: "token";
|
|
4827
|
+
}>;
|
|
4828
|
+
name: z.ZodString;
|
|
4829
|
+
}, z.core.$strip>;
|
|
4830
|
+
};
|
|
4831
|
+
FORBIDDEN: {
|
|
4832
|
+
readonly message: "Not allowed";
|
|
4833
|
+
};
|
|
4834
|
+
PRECONDITION_FAILED: {
|
|
4835
|
+
readonly message: "Not possible on this host";
|
|
4836
|
+
};
|
|
4837
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4838
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4839
|
+
readonly status: 503;
|
|
4840
|
+
readonly data: z.ZodObject<{
|
|
4841
|
+
budgetMib: z.ZodInt;
|
|
4842
|
+
usedMib: z.ZodInt;
|
|
4843
|
+
requestedMib: z.ZodInt;
|
|
4844
|
+
}, z.core.$strip>;
|
|
4845
|
+
};
|
|
4846
|
+
SERVICE_UNAVAILABLE: {
|
|
4847
|
+
readonly message: "impd is stopping";
|
|
4848
|
+
};
|
|
4849
|
+
INVALID_STATE: {
|
|
4850
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4851
|
+
readonly status: 409;
|
|
4852
|
+
readonly data: z.ZodObject<{
|
|
4853
|
+
state: z.ZodEnum<{
|
|
4854
|
+
creating: "creating";
|
|
4855
|
+
error: "error";
|
|
4856
|
+
running: "running";
|
|
4857
|
+
sleeping: "sleeping";
|
|
4858
|
+
stopped: "stopped";
|
|
4859
|
+
}>;
|
|
4860
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4861
|
+
creating: "creating";
|
|
4862
|
+
error: "error";
|
|
4863
|
+
running: "running";
|
|
4864
|
+
sleeping: "sleeping";
|
|
4865
|
+
stopped: "stopped";
|
|
4866
|
+
}>>;
|
|
4867
|
+
}, z.core.$strip>;
|
|
4868
|
+
};
|
|
4869
|
+
DISK_FULL: {
|
|
4870
|
+
readonly message: "Not enough free disk on the host";
|
|
4871
|
+
readonly status: 507;
|
|
4872
|
+
readonly data: z.ZodObject<{
|
|
4873
|
+
availableBytes: z.ZodInt;
|
|
4874
|
+
reserveBytes: z.ZodInt;
|
|
4875
|
+
requestedBytes: z.ZodInt;
|
|
4876
|
+
}, z.core.$strip>;
|
|
4877
|
+
};
|
|
4878
|
+
AGENT_OUTDATED: {
|
|
4879
|
+
readonly message: "The imp's agent is too old for this";
|
|
4880
|
+
readonly status: 409;
|
|
4881
|
+
};
|
|
4882
|
+
}>, Record<never, never>>;
|
|
4883
|
+
whoami: import("@orpc/contract").ContractProcedureBuilderWithOutput<import("@orpc/contract").Schema<unknown, unknown>, z.ZodObject<{
|
|
4884
|
+
kind: z.ZodEnum<{
|
|
4885
|
+
dashboard: "dashboard";
|
|
4886
|
+
ssh: "ssh";
|
|
4887
|
+
tailnet: "tailnet";
|
|
4888
|
+
token: "token";
|
|
4889
|
+
}>;
|
|
4890
|
+
name: z.ZodString;
|
|
4891
|
+
scope: z.ZodEnum<{
|
|
4892
|
+
exec: "exec";
|
|
4893
|
+
manage: "manage";
|
|
4894
|
+
read: "read";
|
|
4895
|
+
}>;
|
|
4896
|
+
imps: z.ZodNullable<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
|
|
4897
|
+
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
4898
|
+
NOT_FOUND: {
|
|
4899
|
+
readonly message: "Not found";
|
|
4900
|
+
readonly data: z.ZodObject<{
|
|
4901
|
+
kind: z.ZodEnum<{
|
|
4902
|
+
backup: "backup";
|
|
4903
|
+
checkpoint: "checkpoint";
|
|
4904
|
+
grant: "grant";
|
|
4905
|
+
image: "image";
|
|
4906
|
+
imp: "imp";
|
|
4907
|
+
secret: "secret";
|
|
4908
|
+
session: "session";
|
|
4909
|
+
token: "token";
|
|
4910
|
+
}>;
|
|
4911
|
+
name: z.ZodString;
|
|
4912
|
+
}, z.core.$strip>;
|
|
4913
|
+
};
|
|
4914
|
+
CONFLICT: {
|
|
4915
|
+
readonly message: "Already exists";
|
|
4916
|
+
readonly data: z.ZodObject<{
|
|
4917
|
+
kind: z.ZodEnum<{
|
|
4918
|
+
backup: "backup";
|
|
4919
|
+
checkpoint: "checkpoint";
|
|
4920
|
+
grant: "grant";
|
|
4921
|
+
image: "image";
|
|
4922
|
+
imp: "imp";
|
|
4923
|
+
secret: "secret";
|
|
4924
|
+
session: "session";
|
|
4925
|
+
token: "token";
|
|
4926
|
+
}>;
|
|
4927
|
+
name: z.ZodString;
|
|
4928
|
+
}, z.core.$strip>;
|
|
4929
|
+
};
|
|
4930
|
+
FORBIDDEN: {
|
|
4931
|
+
readonly message: "Not allowed";
|
|
4932
|
+
};
|
|
4933
|
+
PRECONDITION_FAILED: {
|
|
4934
|
+
readonly message: "Not possible on this host";
|
|
4935
|
+
};
|
|
4936
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4937
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4938
|
+
readonly status: 503;
|
|
4939
|
+
readonly data: z.ZodObject<{
|
|
4940
|
+
budgetMib: z.ZodInt;
|
|
4941
|
+
usedMib: z.ZodInt;
|
|
4942
|
+
requestedMib: z.ZodInt;
|
|
4943
|
+
}, z.core.$strip>;
|
|
4944
|
+
};
|
|
4945
|
+
SERVICE_UNAVAILABLE: {
|
|
4946
|
+
readonly message: "impd is stopping";
|
|
4947
|
+
};
|
|
4948
|
+
INVALID_STATE: {
|
|
4949
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4950
|
+
readonly status: 409;
|
|
4951
|
+
readonly data: z.ZodObject<{
|
|
4952
|
+
state: z.ZodEnum<{
|
|
4953
|
+
creating: "creating";
|
|
4954
|
+
error: "error";
|
|
4955
|
+
running: "running";
|
|
4956
|
+
sleeping: "sleeping";
|
|
4957
|
+
stopped: "stopped";
|
|
4958
|
+
}>;
|
|
4959
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4960
|
+
creating: "creating";
|
|
4961
|
+
error: "error";
|
|
4962
|
+
running: "running";
|
|
4963
|
+
sleeping: "sleeping";
|
|
4964
|
+
stopped: "stopped";
|
|
4965
|
+
}>>;
|
|
4966
|
+
}, z.core.$strip>;
|
|
4967
|
+
};
|
|
4968
|
+
DISK_FULL: {
|
|
4969
|
+
readonly message: "Not enough free disk on the host";
|
|
4970
|
+
readonly status: 507;
|
|
4971
|
+
readonly data: z.ZodObject<{
|
|
4972
|
+
availableBytes: z.ZodInt;
|
|
4973
|
+
reserveBytes: z.ZodInt;
|
|
4974
|
+
requestedBytes: z.ZodInt;
|
|
4975
|
+
}, z.core.$strip>;
|
|
4976
|
+
};
|
|
4977
|
+
AGENT_OUTDATED: {
|
|
4978
|
+
readonly message: "The imp's agent is too old for this";
|
|
4979
|
+
readonly status: 409;
|
|
4980
|
+
};
|
|
4981
|
+
}>, Record<never, never>>;
|
|
4982
|
+
};
|
|
4983
|
+
};
|
|
4984
|
+
type ImpContract = typeof impContract;
|
|
4985
|
+
//#endregion
|
|
4986
|
+
//#region ../api/src/imp-schema.d.ts
|
|
4987
|
+
declare const ImpStateSchema: z.ZodEnum<{
|
|
4988
|
+
creating: "creating";
|
|
4989
|
+
error: "error";
|
|
4990
|
+
running: "running";
|
|
4991
|
+
sleeping: "sleeping";
|
|
4992
|
+
stopped: "stopped";
|
|
4993
|
+
}>;
|
|
4994
|
+
type ImpState = z.infer<typeof ImpStateSchema>;
|
|
4995
|
+
declare const ImpSchema: z.ZodObject<{
|
|
4996
|
+
id: z.ZodString;
|
|
4997
|
+
name: z.ZodString;
|
|
4998
|
+
image: z.ZodString;
|
|
4999
|
+
state: z.ZodEnum<{
|
|
5000
|
+
creating: "creating";
|
|
5001
|
+
error: "error";
|
|
5002
|
+
running: "running";
|
|
5003
|
+
sleeping: "sleeping";
|
|
5004
|
+
stopped: "stopped";
|
|
5005
|
+
}>;
|
|
5006
|
+
vcpus: z.ZodInt;
|
|
5007
|
+
memoryMib: z.ZodInt;
|
|
5008
|
+
diskMib: z.ZodInt;
|
|
5009
|
+
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
5010
|
+
exclusiveBytes: z.ZodInt;
|
|
5011
|
+
sharedBytes: z.ZodInt;
|
|
5012
|
+
measuredAt: z.ZodDate;
|
|
5013
|
+
isPartial: z.ZodBoolean;
|
|
5014
|
+
isUpperBound: z.ZodBoolean;
|
|
5015
|
+
}, z.core.$strip>>;
|
|
3818
5016
|
ip: z.ZodIPv4;
|
|
3819
5017
|
slot: z.ZodInt;
|
|
3820
5018
|
port: z.ZodInt;
|
|
@@ -3894,6 +5092,10 @@ declare const SystemInfoSchema: z.ZodObject<{
|
|
|
3894
5092
|
}>;
|
|
3895
5093
|
usedBytes: z.ZodInt;
|
|
3896
5094
|
availableBytes: z.ZodInt;
|
|
5095
|
+
reserveBytes: z.ZodInt;
|
|
5096
|
+
pendingBytes: z.ZodInt;
|
|
5097
|
+
isLow: z.ZodBoolean;
|
|
5098
|
+
impDiskBytes: z.ZodInt;
|
|
3897
5099
|
}, z.core.$strip>;
|
|
3898
5100
|
tailscale: z.ZodObject<{
|
|
3899
5101
|
enabled: z.ZodBoolean;
|
|
@@ -3904,6 +5106,41 @@ declare const SystemInfoSchema: z.ZodObject<{
|
|
|
3904
5106
|
}, z.core.$strip>;
|
|
3905
5107
|
type SystemInfo = z.infer<typeof SystemInfoSchema>;
|
|
3906
5108
|
//#endregion
|
|
5109
|
+
//#region ../api/src/token-schema.d.ts
|
|
5110
|
+
declare const ScopeSchema: z.ZodEnum<{
|
|
5111
|
+
exec: "exec";
|
|
5112
|
+
manage: "manage";
|
|
5113
|
+
read: "read";
|
|
5114
|
+
}>;
|
|
5115
|
+
type Scope = z.infer<typeof ScopeSchema>;
|
|
5116
|
+
declare const TokenSchema: z.ZodObject<{
|
|
5117
|
+
name: z.ZodString;
|
|
5118
|
+
scope: z.ZodEnum<{
|
|
5119
|
+
exec: "exec";
|
|
5120
|
+
manage: "manage";
|
|
5121
|
+
read: "read";
|
|
5122
|
+
}>;
|
|
5123
|
+
imps: z.ZodNullable<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
|
|
5124
|
+
createdAt: z.ZodDate;
|
|
5125
|
+
}, z.core.$strip>;
|
|
5126
|
+
type Token = z.infer<typeof TokenSchema>;
|
|
5127
|
+
declare const IdentitySchema: z.ZodObject<{
|
|
5128
|
+
kind: z.ZodEnum<{
|
|
5129
|
+
dashboard: "dashboard";
|
|
5130
|
+
ssh: "ssh";
|
|
5131
|
+
tailnet: "tailnet";
|
|
5132
|
+
token: "token";
|
|
5133
|
+
}>;
|
|
5134
|
+
name: z.ZodString;
|
|
5135
|
+
scope: z.ZodEnum<{
|
|
5136
|
+
exec: "exec";
|
|
5137
|
+
manage: "manage";
|
|
5138
|
+
read: "read";
|
|
5139
|
+
}>;
|
|
5140
|
+
imps: z.ZodNullable<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
|
|
5141
|
+
}, z.core.$strip>;
|
|
5142
|
+
type Identity = z.infer<typeof IdentitySchema>;
|
|
5143
|
+
//#endregion
|
|
3907
5144
|
//#region src/check-server.d.ts
|
|
3908
5145
|
export declare const CLIENT_VERSION: string;
|
|
3909
5146
|
interface ServerCheck {
|
|
@@ -4059,4 +5296,4 @@ export declare class ExecError extends Error {
|
|
|
4059
5296
|
}>);
|
|
4060
5297
|
}
|
|
4061
5298
|
//#endregion
|
|
4062
|
-
export { type ApiCall, type AttachOptions, type Checkpoint, type ConsoleOptions, type DetachReason, type ExecClientErrorCode, type ExecExit, type ExecHandle, type ExecOptions, type ExecOutcome, type ExecSession, type ExecSessionOptions, type ExecStarted, type Image, type Imp, type ImpClient, type ImpClientOptions, type ImpEvent, type ImpState, ORPCError, type RequireAwakeOptions, type RunOptions, type RunResult, type ServerCheck, type Session, type SystemInfo, isDefinedError, safe };
|
|
5299
|
+
export { type ApiCall, type AttachOptions, type Checkpoint, type ConsoleOptions, type DetachReason, type ExecClientErrorCode, type ExecExit, type ExecHandle, type ExecOptions, type ExecOutcome, type ExecSession, type ExecSessionOptions, type ExecStarted, type Identity, type Image, type Imp, type ImpClient, type ImpClientOptions, type ImpEvent, type ImpState, ORPCError, type RequireAwakeOptions, type RunOptions, type RunResult, type Scope, type ServerCheck, type Session, type SystemInfo, type Token, isDefinedError, safe };
|