@zgeoff/imp-client 0.13.1 → 0.15.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 +2553 -33
- package/dist/index.js +2 -1
- package/package.json +1 -1
package/dist/index.d.ts
CHANGED
|
@@ -80,6 +80,18 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
80
80
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
81
81
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
82
82
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
83
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
84
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
85
|
+
name: z.ZodString;
|
|
86
|
+
owner: z.ZodObject<{
|
|
87
|
+
principal: z.ZodString;
|
|
88
|
+
display: z.ZodString;
|
|
89
|
+
label: z.ZodString;
|
|
90
|
+
}, z.core.$strip>;
|
|
91
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
92
|
+
}, z.core.$strip>>>;
|
|
93
|
+
otherCount: z.ZodInt;
|
|
94
|
+
}, z.core.$strip>>;
|
|
83
95
|
error: z.ZodOptional<z.ZodString>;
|
|
84
96
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
85
97
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -118,6 +130,7 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
118
130
|
exposed: "exposed";
|
|
119
131
|
failed: "failed";
|
|
120
132
|
held: "held";
|
|
133
|
+
released: "released";
|
|
121
134
|
repaired: "repaired";
|
|
122
135
|
resized: "resized";
|
|
123
136
|
restored: "restored";
|
|
@@ -165,6 +178,18 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
165
178
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
166
179
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
167
180
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
181
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
182
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
183
|
+
name: z.ZodString;
|
|
184
|
+
owner: z.ZodObject<{
|
|
185
|
+
principal: z.ZodString;
|
|
186
|
+
display: z.ZodString;
|
|
187
|
+
label: z.ZodString;
|
|
188
|
+
}, z.core.$strip>;
|
|
189
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
190
|
+
}, z.core.$strip>>>;
|
|
191
|
+
otherCount: z.ZodInt;
|
|
192
|
+
}, z.core.$strip>>;
|
|
168
193
|
error: z.ZodOptional<z.ZodString>;
|
|
169
194
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
170
195
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -198,6 +223,7 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
198
223
|
trigger: z.ZodOptional<z.ZodString>;
|
|
199
224
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
200
225
|
steps: z.ZodOptional<z.ZodReadonly<z.ZodRecord<z.ZodString, z.ZodInt>>>;
|
|
226
|
+
released: z.ZodOptional<z.ZodInt>;
|
|
201
227
|
}, z.core.$strip>>>;
|
|
202
228
|
}, z.core.$strip>, z.ZodObject<{
|
|
203
229
|
v: z.ZodLiteral<1>;
|
|
@@ -242,6 +268,18 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
242
268
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
243
269
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
244
270
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
271
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
272
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
273
|
+
name: z.ZodString;
|
|
274
|
+
owner: z.ZodObject<{
|
|
275
|
+
principal: z.ZodString;
|
|
276
|
+
display: z.ZodString;
|
|
277
|
+
label: z.ZodString;
|
|
278
|
+
}, z.core.$strip>;
|
|
279
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
280
|
+
}, z.core.$strip>>>;
|
|
281
|
+
otherCount: z.ZodInt;
|
|
282
|
+
}, z.core.$strip>>;
|
|
245
283
|
error: z.ZodOptional<z.ZodString>;
|
|
246
284
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
247
285
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -308,6 +346,8 @@ declare const ImpEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
|
|
|
308
346
|
usedMib: z.ZodInt;
|
|
309
347
|
budgetMib: z.ZodInt;
|
|
310
348
|
reserveMib: z.ZodOptional<z.ZodInt>;
|
|
349
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
350
|
+
protectedCount: z.ZodOptional<z.ZodInt>;
|
|
311
351
|
}, z.core.$strip>], "ev">;
|
|
312
352
|
type ImpEvent = z.infer<typeof ImpEventSchema>;
|
|
313
353
|
//#endregion
|
|
@@ -386,6 +426,18 @@ declare const impContract: {
|
|
|
386
426
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
387
427
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
388
428
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
429
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
430
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
431
|
+
name: z.ZodString;
|
|
432
|
+
owner: z.ZodObject<{
|
|
433
|
+
principal: z.ZodString;
|
|
434
|
+
display: z.ZodString;
|
|
435
|
+
label: z.ZodString;
|
|
436
|
+
}, z.core.$strip>;
|
|
437
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
438
|
+
}, z.core.$strip>>>;
|
|
439
|
+
otherCount: z.ZodInt;
|
|
440
|
+
}, z.core.$strip>>;
|
|
389
441
|
error: z.ZodOptional<z.ZodString>;
|
|
390
442
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
391
443
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -465,6 +517,14 @@ declare const impContract: {
|
|
|
465
517
|
budgetMib: z.ZodInt;
|
|
466
518
|
usedMib: z.ZodInt;
|
|
467
519
|
requestedMib: z.ZodInt;
|
|
520
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
521
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
522
|
+
name: z.ZodString;
|
|
523
|
+
ramMib: z.ZodInt;
|
|
524
|
+
leased: z.ZodBoolean;
|
|
525
|
+
busy: z.ZodBoolean;
|
|
526
|
+
}, z.core.$strip>>>>;
|
|
527
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
468
528
|
}, z.core.$strip>;
|
|
469
529
|
};
|
|
470
530
|
SERVICE_UNAVAILABLE: {
|
|
@@ -499,6 +559,26 @@ declare const impContract: {
|
|
|
499
559
|
requestedBytes: z.ZodInt;
|
|
500
560
|
}, z.core.$strip>;
|
|
501
561
|
};
|
|
562
|
+
LEASED: {
|
|
563
|
+
readonly message: "The imp is leased";
|
|
564
|
+
readonly status: 409;
|
|
565
|
+
readonly data: z.ZodObject<{
|
|
566
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
567
|
+
name: z.ZodString;
|
|
568
|
+
owner: z.ZodObject<{
|
|
569
|
+
principal: z.ZodString;
|
|
570
|
+
display: z.ZodString;
|
|
571
|
+
label: z.ZodString;
|
|
572
|
+
}, z.core.$strip>;
|
|
573
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
574
|
+
}, z.core.$strip>>>;
|
|
575
|
+
otherCount: z.ZodInt;
|
|
576
|
+
}, z.core.$strip>;
|
|
577
|
+
};
|
|
578
|
+
LEASE_NOT_HELD: {
|
|
579
|
+
readonly message: "The caller holds no such lease";
|
|
580
|
+
readonly status: 409;
|
|
581
|
+
};
|
|
502
582
|
AGENT_OUTDATED: {
|
|
503
583
|
readonly message: "The imp's agent is too old for this";
|
|
504
584
|
readonly status: 409;
|
|
@@ -543,6 +623,18 @@ declare const impContract: {
|
|
|
543
623
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
544
624
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
545
625
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
626
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
627
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
628
|
+
name: z.ZodString;
|
|
629
|
+
owner: z.ZodObject<{
|
|
630
|
+
principal: z.ZodString;
|
|
631
|
+
display: z.ZodString;
|
|
632
|
+
label: z.ZodString;
|
|
633
|
+
}, z.core.$strip>;
|
|
634
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
635
|
+
}, z.core.$strip>>>;
|
|
636
|
+
otherCount: z.ZodInt;
|
|
637
|
+
}, z.core.$strip>>;
|
|
546
638
|
error: z.ZodOptional<z.ZodString>;
|
|
547
639
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
548
640
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -622,6 +714,14 @@ declare const impContract: {
|
|
|
622
714
|
budgetMib: z.ZodInt;
|
|
623
715
|
usedMib: z.ZodInt;
|
|
624
716
|
requestedMib: z.ZodInt;
|
|
717
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
718
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
719
|
+
name: z.ZodString;
|
|
720
|
+
ramMib: z.ZodInt;
|
|
721
|
+
leased: z.ZodBoolean;
|
|
722
|
+
busy: z.ZodBoolean;
|
|
723
|
+
}, z.core.$strip>>>>;
|
|
724
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
625
725
|
}, z.core.$strip>;
|
|
626
726
|
};
|
|
627
727
|
SERVICE_UNAVAILABLE: {
|
|
@@ -656,6 +756,26 @@ declare const impContract: {
|
|
|
656
756
|
requestedBytes: z.ZodInt;
|
|
657
757
|
}, z.core.$strip>;
|
|
658
758
|
};
|
|
759
|
+
LEASED: {
|
|
760
|
+
readonly message: "The imp is leased";
|
|
761
|
+
readonly status: 409;
|
|
762
|
+
readonly data: z.ZodObject<{
|
|
763
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
764
|
+
name: z.ZodString;
|
|
765
|
+
owner: z.ZodObject<{
|
|
766
|
+
principal: z.ZodString;
|
|
767
|
+
display: z.ZodString;
|
|
768
|
+
label: z.ZodString;
|
|
769
|
+
}, z.core.$strip>;
|
|
770
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
771
|
+
}, z.core.$strip>>>;
|
|
772
|
+
otherCount: z.ZodInt;
|
|
773
|
+
}, z.core.$strip>;
|
|
774
|
+
};
|
|
775
|
+
LEASE_NOT_HELD: {
|
|
776
|
+
readonly message: "The caller holds no such lease";
|
|
777
|
+
readonly status: 409;
|
|
778
|
+
};
|
|
659
779
|
AGENT_OUTDATED: {
|
|
660
780
|
readonly message: "The imp's agent is too old for this";
|
|
661
781
|
readonly status: 409;
|
|
@@ -702,6 +822,18 @@ declare const impContract: {
|
|
|
702
822
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
703
823
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
704
824
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
825
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
826
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
827
|
+
name: z.ZodString;
|
|
828
|
+
owner: z.ZodObject<{
|
|
829
|
+
principal: z.ZodString;
|
|
830
|
+
display: z.ZodString;
|
|
831
|
+
label: z.ZodString;
|
|
832
|
+
}, z.core.$strip>;
|
|
833
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
834
|
+
}, z.core.$strip>>>;
|
|
835
|
+
otherCount: z.ZodInt;
|
|
836
|
+
}, z.core.$strip>>;
|
|
705
837
|
error: z.ZodOptional<z.ZodString>;
|
|
706
838
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
707
839
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -781,6 +913,14 @@ declare const impContract: {
|
|
|
781
913
|
budgetMib: z.ZodInt;
|
|
782
914
|
usedMib: z.ZodInt;
|
|
783
915
|
requestedMib: z.ZodInt;
|
|
916
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
917
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
918
|
+
name: z.ZodString;
|
|
919
|
+
ramMib: z.ZodInt;
|
|
920
|
+
leased: z.ZodBoolean;
|
|
921
|
+
busy: z.ZodBoolean;
|
|
922
|
+
}, z.core.$strip>>>>;
|
|
923
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
784
924
|
}, z.core.$strip>;
|
|
785
925
|
};
|
|
786
926
|
SERVICE_UNAVAILABLE: {
|
|
@@ -815,6 +955,26 @@ declare const impContract: {
|
|
|
815
955
|
requestedBytes: z.ZodInt;
|
|
816
956
|
}, z.core.$strip>;
|
|
817
957
|
};
|
|
958
|
+
LEASED: {
|
|
959
|
+
readonly message: "The imp is leased";
|
|
960
|
+
readonly status: 409;
|
|
961
|
+
readonly data: z.ZodObject<{
|
|
962
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
963
|
+
name: z.ZodString;
|
|
964
|
+
owner: z.ZodObject<{
|
|
965
|
+
principal: z.ZodString;
|
|
966
|
+
display: z.ZodString;
|
|
967
|
+
label: z.ZodString;
|
|
968
|
+
}, z.core.$strip>;
|
|
969
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
970
|
+
}, z.core.$strip>>>;
|
|
971
|
+
otherCount: z.ZodInt;
|
|
972
|
+
}, z.core.$strip>;
|
|
973
|
+
};
|
|
974
|
+
LEASE_NOT_HELD: {
|
|
975
|
+
readonly message: "The caller holds no such lease";
|
|
976
|
+
readonly status: 409;
|
|
977
|
+
};
|
|
818
978
|
AGENT_OUTDATED: {
|
|
819
979
|
readonly message: "The imp's agent is too old for this";
|
|
820
980
|
readonly status: 409;
|
|
@@ -874,6 +1034,14 @@ declare const impContract: {
|
|
|
874
1034
|
budgetMib: z.ZodInt;
|
|
875
1035
|
usedMib: z.ZodInt;
|
|
876
1036
|
requestedMib: z.ZodInt;
|
|
1037
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
1038
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1039
|
+
name: z.ZodString;
|
|
1040
|
+
ramMib: z.ZodInt;
|
|
1041
|
+
leased: z.ZodBoolean;
|
|
1042
|
+
busy: z.ZodBoolean;
|
|
1043
|
+
}, z.core.$strip>>>>;
|
|
1044
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
877
1045
|
}, z.core.$strip>;
|
|
878
1046
|
};
|
|
879
1047
|
SERVICE_UNAVAILABLE: {
|
|
@@ -908,6 +1076,26 @@ declare const impContract: {
|
|
|
908
1076
|
requestedBytes: z.ZodInt;
|
|
909
1077
|
}, z.core.$strip>;
|
|
910
1078
|
};
|
|
1079
|
+
LEASED: {
|
|
1080
|
+
readonly message: "The imp is leased";
|
|
1081
|
+
readonly status: 409;
|
|
1082
|
+
readonly data: z.ZodObject<{
|
|
1083
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1084
|
+
name: z.ZodString;
|
|
1085
|
+
owner: z.ZodObject<{
|
|
1086
|
+
principal: z.ZodString;
|
|
1087
|
+
display: z.ZodString;
|
|
1088
|
+
label: z.ZodString;
|
|
1089
|
+
}, z.core.$strip>;
|
|
1090
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1091
|
+
}, z.core.$strip>>>;
|
|
1092
|
+
otherCount: z.ZodInt;
|
|
1093
|
+
}, z.core.$strip>;
|
|
1094
|
+
};
|
|
1095
|
+
LEASE_NOT_HELD: {
|
|
1096
|
+
readonly message: "The caller holds no such lease";
|
|
1097
|
+
readonly status: 409;
|
|
1098
|
+
};
|
|
911
1099
|
AGENT_OUTDATED: {
|
|
912
1100
|
readonly message: "The imp's agent is too old for this";
|
|
913
1101
|
readonly status: 409;
|
|
@@ -954,6 +1142,18 @@ declare const impContract: {
|
|
|
954
1142
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
955
1143
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
956
1144
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
1145
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
1146
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1147
|
+
name: z.ZodString;
|
|
1148
|
+
owner: z.ZodObject<{
|
|
1149
|
+
principal: z.ZodString;
|
|
1150
|
+
display: z.ZodString;
|
|
1151
|
+
label: z.ZodString;
|
|
1152
|
+
}, z.core.$strip>;
|
|
1153
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1154
|
+
}, z.core.$strip>>>;
|
|
1155
|
+
otherCount: z.ZodInt;
|
|
1156
|
+
}, z.core.$strip>>;
|
|
957
1157
|
error: z.ZodOptional<z.ZodString>;
|
|
958
1158
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
959
1159
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -1033,6 +1233,14 @@ declare const impContract: {
|
|
|
1033
1233
|
budgetMib: z.ZodInt;
|
|
1034
1234
|
usedMib: z.ZodInt;
|
|
1035
1235
|
requestedMib: z.ZodInt;
|
|
1236
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
1237
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1238
|
+
name: z.ZodString;
|
|
1239
|
+
ramMib: z.ZodInt;
|
|
1240
|
+
leased: z.ZodBoolean;
|
|
1241
|
+
busy: z.ZodBoolean;
|
|
1242
|
+
}, z.core.$strip>>>>;
|
|
1243
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1036
1244
|
}, z.core.$strip>;
|
|
1037
1245
|
};
|
|
1038
1246
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1067,6 +1275,26 @@ declare const impContract: {
|
|
|
1067
1275
|
requestedBytes: z.ZodInt;
|
|
1068
1276
|
}, z.core.$strip>;
|
|
1069
1277
|
};
|
|
1278
|
+
LEASED: {
|
|
1279
|
+
readonly message: "The imp is leased";
|
|
1280
|
+
readonly status: 409;
|
|
1281
|
+
readonly data: z.ZodObject<{
|
|
1282
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1283
|
+
name: z.ZodString;
|
|
1284
|
+
owner: z.ZodObject<{
|
|
1285
|
+
principal: z.ZodString;
|
|
1286
|
+
display: z.ZodString;
|
|
1287
|
+
label: z.ZodString;
|
|
1288
|
+
}, z.core.$strip>;
|
|
1289
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1290
|
+
}, z.core.$strip>>>;
|
|
1291
|
+
otherCount: z.ZodInt;
|
|
1292
|
+
}, z.core.$strip>;
|
|
1293
|
+
};
|
|
1294
|
+
LEASE_NOT_HELD: {
|
|
1295
|
+
readonly message: "The caller holds no such lease";
|
|
1296
|
+
readonly status: 409;
|
|
1297
|
+
};
|
|
1070
1298
|
AGENT_OUTDATED: {
|
|
1071
1299
|
readonly message: "The imp's agent is too old for this";
|
|
1072
1300
|
readonly status: 409;
|
|
@@ -1074,6 +1302,7 @@ declare const impContract: {
|
|
|
1074
1302
|
}>, Record<never, never>>;
|
|
1075
1303
|
stop: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
1076
1304
|
name: z.ZodString;
|
|
1305
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
1077
1306
|
}, z.core.$strip>, z.ZodObject<{
|
|
1078
1307
|
id: z.ZodString;
|
|
1079
1308
|
name: z.ZodString;
|
|
@@ -1113,6 +1342,18 @@ declare const impContract: {
|
|
|
1113
1342
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
1114
1343
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
1115
1344
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
1345
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
1346
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1347
|
+
name: z.ZodString;
|
|
1348
|
+
owner: z.ZodObject<{
|
|
1349
|
+
principal: z.ZodString;
|
|
1350
|
+
display: z.ZodString;
|
|
1351
|
+
label: z.ZodString;
|
|
1352
|
+
}, z.core.$strip>;
|
|
1353
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1354
|
+
}, z.core.$strip>>>;
|
|
1355
|
+
otherCount: z.ZodInt;
|
|
1356
|
+
}, z.core.$strip>>;
|
|
1116
1357
|
error: z.ZodOptional<z.ZodString>;
|
|
1117
1358
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
1118
1359
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -1192,6 +1433,14 @@ declare const impContract: {
|
|
|
1192
1433
|
budgetMib: z.ZodInt;
|
|
1193
1434
|
usedMib: z.ZodInt;
|
|
1194
1435
|
requestedMib: z.ZodInt;
|
|
1436
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
1437
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1438
|
+
name: z.ZodString;
|
|
1439
|
+
ramMib: z.ZodInt;
|
|
1440
|
+
leased: z.ZodBoolean;
|
|
1441
|
+
busy: z.ZodBoolean;
|
|
1442
|
+
}, z.core.$strip>>>>;
|
|
1443
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1195
1444
|
}, z.core.$strip>;
|
|
1196
1445
|
};
|
|
1197
1446
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1226,6 +1475,26 @@ declare const impContract: {
|
|
|
1226
1475
|
requestedBytes: z.ZodInt;
|
|
1227
1476
|
}, z.core.$strip>;
|
|
1228
1477
|
};
|
|
1478
|
+
LEASED: {
|
|
1479
|
+
readonly message: "The imp is leased";
|
|
1480
|
+
readonly status: 409;
|
|
1481
|
+
readonly data: z.ZodObject<{
|
|
1482
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1483
|
+
name: z.ZodString;
|
|
1484
|
+
owner: z.ZodObject<{
|
|
1485
|
+
principal: z.ZodString;
|
|
1486
|
+
display: z.ZodString;
|
|
1487
|
+
label: z.ZodString;
|
|
1488
|
+
}, z.core.$strip>;
|
|
1489
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1490
|
+
}, z.core.$strip>>>;
|
|
1491
|
+
otherCount: z.ZodInt;
|
|
1492
|
+
}, z.core.$strip>;
|
|
1493
|
+
};
|
|
1494
|
+
LEASE_NOT_HELD: {
|
|
1495
|
+
readonly message: "The caller holds no such lease";
|
|
1496
|
+
readonly status: 409;
|
|
1497
|
+
};
|
|
1229
1498
|
AGENT_OUTDATED: {
|
|
1230
1499
|
readonly message: "The imp's agent is too old for this";
|
|
1231
1500
|
readonly status: 409;
|
|
@@ -1233,6 +1502,7 @@ declare const impContract: {
|
|
|
1233
1502
|
}>, Record<never, never>>;
|
|
1234
1503
|
sleep: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
1235
1504
|
name: z.ZodString;
|
|
1505
|
+
force: z.ZodOptional<z.ZodBoolean>;
|
|
1236
1506
|
}, z.core.$strip>, z.ZodObject<{
|
|
1237
1507
|
id: z.ZodString;
|
|
1238
1508
|
name: z.ZodString;
|
|
@@ -1272,6 +1542,18 @@ declare const impContract: {
|
|
|
1272
1542
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
1273
1543
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
1274
1544
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
1545
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
1546
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1547
|
+
name: z.ZodString;
|
|
1548
|
+
owner: z.ZodObject<{
|
|
1549
|
+
principal: z.ZodString;
|
|
1550
|
+
display: z.ZodString;
|
|
1551
|
+
label: z.ZodString;
|
|
1552
|
+
}, z.core.$strip>;
|
|
1553
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1554
|
+
}, z.core.$strip>>>;
|
|
1555
|
+
otherCount: z.ZodInt;
|
|
1556
|
+
}, z.core.$strip>>;
|
|
1275
1557
|
error: z.ZodOptional<z.ZodString>;
|
|
1276
1558
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
1277
1559
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -1351,6 +1633,14 @@ declare const impContract: {
|
|
|
1351
1633
|
budgetMib: z.ZodInt;
|
|
1352
1634
|
usedMib: z.ZodInt;
|
|
1353
1635
|
requestedMib: z.ZodInt;
|
|
1636
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
1637
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1638
|
+
name: z.ZodString;
|
|
1639
|
+
ramMib: z.ZodInt;
|
|
1640
|
+
leased: z.ZodBoolean;
|
|
1641
|
+
busy: z.ZodBoolean;
|
|
1642
|
+
}, z.core.$strip>>>>;
|
|
1643
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1354
1644
|
}, z.core.$strip>;
|
|
1355
1645
|
};
|
|
1356
1646
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1385,6 +1675,26 @@ declare const impContract: {
|
|
|
1385
1675
|
requestedBytes: z.ZodInt;
|
|
1386
1676
|
}, z.core.$strip>;
|
|
1387
1677
|
};
|
|
1678
|
+
LEASED: {
|
|
1679
|
+
readonly message: "The imp is leased";
|
|
1680
|
+
readonly status: 409;
|
|
1681
|
+
readonly data: z.ZodObject<{
|
|
1682
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1683
|
+
name: z.ZodString;
|
|
1684
|
+
owner: z.ZodObject<{
|
|
1685
|
+
principal: z.ZodString;
|
|
1686
|
+
display: z.ZodString;
|
|
1687
|
+
label: z.ZodString;
|
|
1688
|
+
}, z.core.$strip>;
|
|
1689
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1690
|
+
}, z.core.$strip>>>;
|
|
1691
|
+
otherCount: z.ZodInt;
|
|
1692
|
+
}, z.core.$strip>;
|
|
1693
|
+
};
|
|
1694
|
+
LEASE_NOT_HELD: {
|
|
1695
|
+
readonly message: "The caller holds no such lease";
|
|
1696
|
+
readonly status: 409;
|
|
1697
|
+
};
|
|
1388
1698
|
AGENT_OUTDATED: {
|
|
1389
1699
|
readonly message: "The imp's agent is too old for this";
|
|
1390
1700
|
readonly status: 409;
|
|
@@ -1432,6 +1742,18 @@ declare const impContract: {
|
|
|
1432
1742
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
1433
1743
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
1434
1744
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
1745
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
1746
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1747
|
+
name: z.ZodString;
|
|
1748
|
+
owner: z.ZodObject<{
|
|
1749
|
+
principal: z.ZodString;
|
|
1750
|
+
display: z.ZodString;
|
|
1751
|
+
label: z.ZodString;
|
|
1752
|
+
}, z.core.$strip>;
|
|
1753
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1754
|
+
}, z.core.$strip>>>;
|
|
1755
|
+
otherCount: z.ZodInt;
|
|
1756
|
+
}, z.core.$strip>>;
|
|
1435
1757
|
error: z.ZodOptional<z.ZodString>;
|
|
1436
1758
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
1437
1759
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -1511,6 +1833,14 @@ declare const impContract: {
|
|
|
1511
1833
|
budgetMib: z.ZodInt;
|
|
1512
1834
|
usedMib: z.ZodInt;
|
|
1513
1835
|
requestedMib: z.ZodInt;
|
|
1836
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
1837
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1838
|
+
name: z.ZodString;
|
|
1839
|
+
ramMib: z.ZodInt;
|
|
1840
|
+
leased: z.ZodBoolean;
|
|
1841
|
+
busy: z.ZodBoolean;
|
|
1842
|
+
}, z.core.$strip>>>>;
|
|
1843
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1514
1844
|
}, z.core.$strip>;
|
|
1515
1845
|
};
|
|
1516
1846
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1545,6 +1875,26 @@ declare const impContract: {
|
|
|
1545
1875
|
requestedBytes: z.ZodInt;
|
|
1546
1876
|
}, z.core.$strip>;
|
|
1547
1877
|
};
|
|
1878
|
+
LEASED: {
|
|
1879
|
+
readonly message: "The imp is leased";
|
|
1880
|
+
readonly status: 409;
|
|
1881
|
+
readonly data: z.ZodObject<{
|
|
1882
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1883
|
+
name: z.ZodString;
|
|
1884
|
+
owner: z.ZodObject<{
|
|
1885
|
+
principal: z.ZodString;
|
|
1886
|
+
display: z.ZodString;
|
|
1887
|
+
label: z.ZodString;
|
|
1888
|
+
}, z.core.$strip>;
|
|
1889
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1890
|
+
}, z.core.$strip>>>;
|
|
1891
|
+
otherCount: z.ZodInt;
|
|
1892
|
+
}, z.core.$strip>;
|
|
1893
|
+
};
|
|
1894
|
+
LEASE_NOT_HELD: {
|
|
1895
|
+
readonly message: "The caller holds no such lease";
|
|
1896
|
+
readonly status: 409;
|
|
1897
|
+
};
|
|
1548
1898
|
AGENT_OUTDATED: {
|
|
1549
1899
|
readonly message: "The imp's agent is too old for this";
|
|
1550
1900
|
readonly status: 409;
|
|
@@ -1592,6 +1942,18 @@ declare const impContract: {
|
|
|
1592
1942
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
1593
1943
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
1594
1944
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
1945
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
1946
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
1947
|
+
name: z.ZodString;
|
|
1948
|
+
owner: z.ZodObject<{
|
|
1949
|
+
principal: z.ZodString;
|
|
1950
|
+
display: z.ZodString;
|
|
1951
|
+
label: z.ZodString;
|
|
1952
|
+
}, z.core.$strip>;
|
|
1953
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
1954
|
+
}, z.core.$strip>>>;
|
|
1955
|
+
otherCount: z.ZodInt;
|
|
1956
|
+
}, z.core.$strip>>;
|
|
1595
1957
|
error: z.ZodOptional<z.ZodString>;
|
|
1596
1958
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
1597
1959
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -1671,6 +2033,14 @@ declare const impContract: {
|
|
|
1671
2033
|
budgetMib: z.ZodInt;
|
|
1672
2034
|
usedMib: z.ZodInt;
|
|
1673
2035
|
requestedMib: z.ZodInt;
|
|
2036
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2037
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2038
|
+
name: z.ZodString;
|
|
2039
|
+
ramMib: z.ZodInt;
|
|
2040
|
+
leased: z.ZodBoolean;
|
|
2041
|
+
busy: z.ZodBoolean;
|
|
2042
|
+
}, z.core.$strip>>>>;
|
|
2043
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1674
2044
|
}, z.core.$strip>;
|
|
1675
2045
|
};
|
|
1676
2046
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1705,6 +2075,26 @@ declare const impContract: {
|
|
|
1705
2075
|
requestedBytes: z.ZodInt;
|
|
1706
2076
|
}, z.core.$strip>;
|
|
1707
2077
|
};
|
|
2078
|
+
LEASED: {
|
|
2079
|
+
readonly message: "The imp is leased";
|
|
2080
|
+
readonly status: 409;
|
|
2081
|
+
readonly data: z.ZodObject<{
|
|
2082
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2083
|
+
name: z.ZodString;
|
|
2084
|
+
owner: z.ZodObject<{
|
|
2085
|
+
principal: z.ZodString;
|
|
2086
|
+
display: z.ZodString;
|
|
2087
|
+
label: z.ZodString;
|
|
2088
|
+
}, z.core.$strip>;
|
|
2089
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2090
|
+
}, z.core.$strip>>>;
|
|
2091
|
+
otherCount: z.ZodInt;
|
|
2092
|
+
}, z.core.$strip>;
|
|
2093
|
+
};
|
|
2094
|
+
LEASE_NOT_HELD: {
|
|
2095
|
+
readonly message: "The caller holds no such lease";
|
|
2096
|
+
readonly status: 409;
|
|
2097
|
+
};
|
|
1708
2098
|
AGENT_OUTDATED: {
|
|
1709
2099
|
readonly message: "The imp's agent is too old for this";
|
|
1710
2100
|
readonly status: 409;
|
|
@@ -1752,6 +2142,18 @@ declare const impContract: {
|
|
|
1752
2142
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
1753
2143
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
1754
2144
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
2145
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
2146
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2147
|
+
name: z.ZodString;
|
|
2148
|
+
owner: z.ZodObject<{
|
|
2149
|
+
principal: z.ZodString;
|
|
2150
|
+
display: z.ZodString;
|
|
2151
|
+
label: z.ZodString;
|
|
2152
|
+
}, z.core.$strip>;
|
|
2153
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2154
|
+
}, z.core.$strip>>>;
|
|
2155
|
+
otherCount: z.ZodInt;
|
|
2156
|
+
}, z.core.$strip>>;
|
|
1755
2157
|
error: z.ZodOptional<z.ZodString>;
|
|
1756
2158
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
1757
2159
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -1831,6 +2233,14 @@ declare const impContract: {
|
|
|
1831
2233
|
budgetMib: z.ZodInt;
|
|
1832
2234
|
usedMib: z.ZodInt;
|
|
1833
2235
|
requestedMib: z.ZodInt;
|
|
2236
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2237
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2238
|
+
name: z.ZodString;
|
|
2239
|
+
ramMib: z.ZodInt;
|
|
2240
|
+
leased: z.ZodBoolean;
|
|
2241
|
+
busy: z.ZodBoolean;
|
|
2242
|
+
}, z.core.$strip>>>>;
|
|
2243
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1834
2244
|
}, z.core.$strip>;
|
|
1835
2245
|
};
|
|
1836
2246
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1865,6 +2275,26 @@ declare const impContract: {
|
|
|
1865
2275
|
requestedBytes: z.ZodInt;
|
|
1866
2276
|
}, z.core.$strip>;
|
|
1867
2277
|
};
|
|
2278
|
+
LEASED: {
|
|
2279
|
+
readonly message: "The imp is leased";
|
|
2280
|
+
readonly status: 409;
|
|
2281
|
+
readonly data: z.ZodObject<{
|
|
2282
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2283
|
+
name: z.ZodString;
|
|
2284
|
+
owner: z.ZodObject<{
|
|
2285
|
+
principal: z.ZodString;
|
|
2286
|
+
display: z.ZodString;
|
|
2287
|
+
label: z.ZodString;
|
|
2288
|
+
}, z.core.$strip>;
|
|
2289
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2290
|
+
}, z.core.$strip>>>;
|
|
2291
|
+
otherCount: z.ZodInt;
|
|
2292
|
+
}, z.core.$strip>;
|
|
2293
|
+
};
|
|
2294
|
+
LEASE_NOT_HELD: {
|
|
2295
|
+
readonly message: "The caller holds no such lease";
|
|
2296
|
+
readonly status: 409;
|
|
2297
|
+
};
|
|
1868
2298
|
AGENT_OUTDATED: {
|
|
1869
2299
|
readonly message: "The imp's agent is too old for this";
|
|
1870
2300
|
readonly status: 409;
|
|
@@ -1930,6 +2360,14 @@ declare const impContract: {
|
|
|
1930
2360
|
budgetMib: z.ZodInt;
|
|
1931
2361
|
usedMib: z.ZodInt;
|
|
1932
2362
|
requestedMib: z.ZodInt;
|
|
2363
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2364
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2365
|
+
name: z.ZodString;
|
|
2366
|
+
ramMib: z.ZodInt;
|
|
2367
|
+
leased: z.ZodBoolean;
|
|
2368
|
+
busy: z.ZodBoolean;
|
|
2369
|
+
}, z.core.$strip>>>>;
|
|
2370
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
1933
2371
|
}, z.core.$strip>;
|
|
1934
2372
|
};
|
|
1935
2373
|
SERVICE_UNAVAILABLE: {
|
|
@@ -1964,6 +2402,26 @@ declare const impContract: {
|
|
|
1964
2402
|
requestedBytes: z.ZodInt;
|
|
1965
2403
|
}, z.core.$strip>;
|
|
1966
2404
|
};
|
|
2405
|
+
LEASED: {
|
|
2406
|
+
readonly message: "The imp is leased";
|
|
2407
|
+
readonly status: 409;
|
|
2408
|
+
readonly data: z.ZodObject<{
|
|
2409
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2410
|
+
name: z.ZodString;
|
|
2411
|
+
owner: z.ZodObject<{
|
|
2412
|
+
principal: z.ZodString;
|
|
2413
|
+
display: z.ZodString;
|
|
2414
|
+
label: z.ZodString;
|
|
2415
|
+
}, z.core.$strip>;
|
|
2416
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2417
|
+
}, z.core.$strip>>>;
|
|
2418
|
+
otherCount: z.ZodInt;
|
|
2419
|
+
}, z.core.$strip>;
|
|
2420
|
+
};
|
|
2421
|
+
LEASE_NOT_HELD: {
|
|
2422
|
+
readonly message: "The caller holds no such lease";
|
|
2423
|
+
readonly status: 409;
|
|
2424
|
+
};
|
|
1967
2425
|
AGENT_OUTDATED: {
|
|
1968
2426
|
readonly message: "The imp's agent is too old for this";
|
|
1969
2427
|
readonly status: 409;
|
|
@@ -2030,6 +2488,14 @@ declare const impContract: {
|
|
|
2030
2488
|
budgetMib: z.ZodInt;
|
|
2031
2489
|
usedMib: z.ZodInt;
|
|
2032
2490
|
requestedMib: z.ZodInt;
|
|
2491
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2492
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2493
|
+
name: z.ZodString;
|
|
2494
|
+
ramMib: z.ZodInt;
|
|
2495
|
+
leased: z.ZodBoolean;
|
|
2496
|
+
busy: z.ZodBoolean;
|
|
2497
|
+
}, z.core.$strip>>>>;
|
|
2498
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2033
2499
|
}, z.core.$strip>;
|
|
2034
2500
|
};
|
|
2035
2501
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2064,6 +2530,26 @@ declare const impContract: {
|
|
|
2064
2530
|
requestedBytes: z.ZodInt;
|
|
2065
2531
|
}, z.core.$strip>;
|
|
2066
2532
|
};
|
|
2533
|
+
LEASED: {
|
|
2534
|
+
readonly message: "The imp is leased";
|
|
2535
|
+
readonly status: 409;
|
|
2536
|
+
readonly data: z.ZodObject<{
|
|
2537
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2538
|
+
name: z.ZodString;
|
|
2539
|
+
owner: z.ZodObject<{
|
|
2540
|
+
principal: z.ZodString;
|
|
2541
|
+
display: z.ZodString;
|
|
2542
|
+
label: z.ZodString;
|
|
2543
|
+
}, z.core.$strip>;
|
|
2544
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2545
|
+
}, z.core.$strip>>>;
|
|
2546
|
+
otherCount: z.ZodInt;
|
|
2547
|
+
}, z.core.$strip>;
|
|
2548
|
+
};
|
|
2549
|
+
LEASE_NOT_HELD: {
|
|
2550
|
+
readonly message: "The caller holds no such lease";
|
|
2551
|
+
readonly status: 409;
|
|
2552
|
+
};
|
|
2067
2553
|
AGENT_OUTDATED: {
|
|
2068
2554
|
readonly message: "The imp's agent is too old for this";
|
|
2069
2555
|
readonly status: 409;
|
|
@@ -2138,6 +2624,14 @@ declare const impContract: {
|
|
|
2138
2624
|
budgetMib: z.ZodInt;
|
|
2139
2625
|
usedMib: z.ZodInt;
|
|
2140
2626
|
requestedMib: z.ZodInt;
|
|
2627
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2628
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2629
|
+
name: z.ZodString;
|
|
2630
|
+
ramMib: z.ZodInt;
|
|
2631
|
+
leased: z.ZodBoolean;
|
|
2632
|
+
busy: z.ZodBoolean;
|
|
2633
|
+
}, z.core.$strip>>>>;
|
|
2634
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2141
2635
|
}, z.core.$strip>;
|
|
2142
2636
|
};
|
|
2143
2637
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2172,6 +2666,26 @@ declare const impContract: {
|
|
|
2172
2666
|
requestedBytes: z.ZodInt;
|
|
2173
2667
|
}, z.core.$strip>;
|
|
2174
2668
|
};
|
|
2669
|
+
LEASED: {
|
|
2670
|
+
readonly message: "The imp is leased";
|
|
2671
|
+
readonly status: 409;
|
|
2672
|
+
readonly data: z.ZodObject<{
|
|
2673
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2674
|
+
name: z.ZodString;
|
|
2675
|
+
owner: z.ZodObject<{
|
|
2676
|
+
principal: z.ZodString;
|
|
2677
|
+
display: z.ZodString;
|
|
2678
|
+
label: z.ZodString;
|
|
2679
|
+
}, z.core.$strip>;
|
|
2680
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2681
|
+
}, z.core.$strip>>>;
|
|
2682
|
+
otherCount: z.ZodInt;
|
|
2683
|
+
}, z.core.$strip>;
|
|
2684
|
+
};
|
|
2685
|
+
LEASE_NOT_HELD: {
|
|
2686
|
+
readonly message: "The caller holds no such lease";
|
|
2687
|
+
readonly status: 409;
|
|
2688
|
+
};
|
|
2175
2689
|
AGENT_OUTDATED: {
|
|
2176
2690
|
readonly message: "The imp's agent is too old for this";
|
|
2177
2691
|
readonly status: 409;
|
|
@@ -2247,6 +2761,14 @@ declare const impContract: {
|
|
|
2247
2761
|
budgetMib: z.ZodInt;
|
|
2248
2762
|
usedMib: z.ZodInt;
|
|
2249
2763
|
requestedMib: z.ZodInt;
|
|
2764
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2765
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2766
|
+
name: z.ZodString;
|
|
2767
|
+
ramMib: z.ZodInt;
|
|
2768
|
+
leased: z.ZodBoolean;
|
|
2769
|
+
busy: z.ZodBoolean;
|
|
2770
|
+
}, z.core.$strip>>>>;
|
|
2771
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2250
2772
|
}, z.core.$strip>;
|
|
2251
2773
|
};
|
|
2252
2774
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2281,6 +2803,26 @@ declare const impContract: {
|
|
|
2281
2803
|
requestedBytes: z.ZodInt;
|
|
2282
2804
|
}, z.core.$strip>;
|
|
2283
2805
|
};
|
|
2806
|
+
LEASED: {
|
|
2807
|
+
readonly message: "The imp is leased";
|
|
2808
|
+
readonly status: 409;
|
|
2809
|
+
readonly data: z.ZodObject<{
|
|
2810
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2811
|
+
name: z.ZodString;
|
|
2812
|
+
owner: z.ZodObject<{
|
|
2813
|
+
principal: z.ZodString;
|
|
2814
|
+
display: z.ZodString;
|
|
2815
|
+
label: z.ZodString;
|
|
2816
|
+
}, z.core.$strip>;
|
|
2817
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2818
|
+
}, z.core.$strip>>>;
|
|
2819
|
+
otherCount: z.ZodInt;
|
|
2820
|
+
}, z.core.$strip>;
|
|
2821
|
+
};
|
|
2822
|
+
LEASE_NOT_HELD: {
|
|
2823
|
+
readonly message: "The caller holds no such lease";
|
|
2824
|
+
readonly status: 409;
|
|
2825
|
+
};
|
|
2284
2826
|
AGENT_OUTDATED: {
|
|
2285
2827
|
readonly message: "The imp's agent is too old for this";
|
|
2286
2828
|
readonly status: 409;
|
|
@@ -2327,6 +2869,18 @@ declare const impContract: {
|
|
|
2327
2869
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
2328
2870
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
2329
2871
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
2872
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
2873
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2874
|
+
name: z.ZodString;
|
|
2875
|
+
owner: z.ZodObject<{
|
|
2876
|
+
principal: z.ZodString;
|
|
2877
|
+
display: z.ZodString;
|
|
2878
|
+
label: z.ZodString;
|
|
2879
|
+
}, z.core.$strip>;
|
|
2880
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2881
|
+
}, z.core.$strip>>>;
|
|
2882
|
+
otherCount: z.ZodInt;
|
|
2883
|
+
}, z.core.$strip>>;
|
|
2330
2884
|
error: z.ZodOptional<z.ZodString>;
|
|
2331
2885
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
2332
2886
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -2406,6 +2960,14 @@ declare const impContract: {
|
|
|
2406
2960
|
budgetMib: z.ZodInt;
|
|
2407
2961
|
usedMib: z.ZodInt;
|
|
2408
2962
|
requestedMib: z.ZodInt;
|
|
2963
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
2964
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
2965
|
+
name: z.ZodString;
|
|
2966
|
+
ramMib: z.ZodInt;
|
|
2967
|
+
leased: z.ZodBoolean;
|
|
2968
|
+
busy: z.ZodBoolean;
|
|
2969
|
+
}, z.core.$strip>>>>;
|
|
2970
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2409
2971
|
}, z.core.$strip>;
|
|
2410
2972
|
};
|
|
2411
2973
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2440,6 +3002,26 @@ declare const impContract: {
|
|
|
2440
3002
|
requestedBytes: z.ZodInt;
|
|
2441
3003
|
}, z.core.$strip>;
|
|
2442
3004
|
};
|
|
3005
|
+
LEASED: {
|
|
3006
|
+
readonly message: "The imp is leased";
|
|
3007
|
+
readonly status: 409;
|
|
3008
|
+
readonly data: z.ZodObject<{
|
|
3009
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3010
|
+
name: z.ZodString;
|
|
3011
|
+
owner: z.ZodObject<{
|
|
3012
|
+
principal: z.ZodString;
|
|
3013
|
+
display: z.ZodString;
|
|
3014
|
+
label: z.ZodString;
|
|
3015
|
+
}, z.core.$strip>;
|
|
3016
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3017
|
+
}, z.core.$strip>>>;
|
|
3018
|
+
otherCount: z.ZodInt;
|
|
3019
|
+
}, z.core.$strip>;
|
|
3020
|
+
};
|
|
3021
|
+
LEASE_NOT_HELD: {
|
|
3022
|
+
readonly message: "The caller holds no such lease";
|
|
3023
|
+
readonly status: 409;
|
|
3024
|
+
};
|
|
2443
3025
|
AGENT_OUTDATED: {
|
|
2444
3026
|
readonly message: "The imp's agent is too old for this";
|
|
2445
3027
|
readonly status: 409;
|
|
@@ -2488,6 +3070,18 @@ declare const impContract: {
|
|
|
2488
3070
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
2489
3071
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
2490
3072
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
3073
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
3074
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3075
|
+
name: z.ZodString;
|
|
3076
|
+
owner: z.ZodObject<{
|
|
3077
|
+
principal: z.ZodString;
|
|
3078
|
+
display: z.ZodString;
|
|
3079
|
+
label: z.ZodString;
|
|
3080
|
+
}, z.core.$strip>;
|
|
3081
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3082
|
+
}, z.core.$strip>>>;
|
|
3083
|
+
otherCount: z.ZodInt;
|
|
3084
|
+
}, z.core.$strip>>;
|
|
2491
3085
|
error: z.ZodOptional<z.ZodString>;
|
|
2492
3086
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
2493
3087
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -2567,6 +3161,14 @@ declare const impContract: {
|
|
|
2567
3161
|
budgetMib: z.ZodInt;
|
|
2568
3162
|
usedMib: z.ZodInt;
|
|
2569
3163
|
requestedMib: z.ZodInt;
|
|
3164
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
3165
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3166
|
+
name: z.ZodString;
|
|
3167
|
+
ramMib: z.ZodInt;
|
|
3168
|
+
leased: z.ZodBoolean;
|
|
3169
|
+
busy: z.ZodBoolean;
|
|
3170
|
+
}, z.core.$strip>>>>;
|
|
3171
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2570
3172
|
}, z.core.$strip>;
|
|
2571
3173
|
};
|
|
2572
3174
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2601,6 +3203,26 @@ declare const impContract: {
|
|
|
2601
3203
|
requestedBytes: z.ZodInt;
|
|
2602
3204
|
}, z.core.$strip>;
|
|
2603
3205
|
};
|
|
3206
|
+
LEASED: {
|
|
3207
|
+
readonly message: "The imp is leased";
|
|
3208
|
+
readonly status: 409;
|
|
3209
|
+
readonly data: z.ZodObject<{
|
|
3210
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3211
|
+
name: z.ZodString;
|
|
3212
|
+
owner: z.ZodObject<{
|
|
3213
|
+
principal: z.ZodString;
|
|
3214
|
+
display: z.ZodString;
|
|
3215
|
+
label: z.ZodString;
|
|
3216
|
+
}, z.core.$strip>;
|
|
3217
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3218
|
+
}, z.core.$strip>>>;
|
|
3219
|
+
otherCount: z.ZodInt;
|
|
3220
|
+
}, z.core.$strip>;
|
|
3221
|
+
};
|
|
3222
|
+
LEASE_NOT_HELD: {
|
|
3223
|
+
readonly message: "The caller holds no such lease";
|
|
3224
|
+
readonly status: 409;
|
|
3225
|
+
};
|
|
2604
3226
|
AGENT_OUTDATED: {
|
|
2605
3227
|
readonly message: "The imp's agent is too old for this";
|
|
2606
3228
|
readonly status: 409;
|
|
@@ -2651,6 +3273,18 @@ declare const impContract: {
|
|
|
2651
3273
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
2652
3274
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
2653
3275
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
3276
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
3277
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3278
|
+
name: z.ZodString;
|
|
3279
|
+
owner: z.ZodObject<{
|
|
3280
|
+
principal: z.ZodString;
|
|
3281
|
+
display: z.ZodString;
|
|
3282
|
+
label: z.ZodString;
|
|
3283
|
+
}, z.core.$strip>;
|
|
3284
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3285
|
+
}, z.core.$strip>>>;
|
|
3286
|
+
otherCount: z.ZodInt;
|
|
3287
|
+
}, z.core.$strip>>;
|
|
2654
3288
|
error: z.ZodOptional<z.ZodString>;
|
|
2655
3289
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
2656
3290
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -2730,6 +3364,14 @@ declare const impContract: {
|
|
|
2730
3364
|
budgetMib: z.ZodInt;
|
|
2731
3365
|
usedMib: z.ZodInt;
|
|
2732
3366
|
requestedMib: z.ZodInt;
|
|
3367
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
3368
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3369
|
+
name: z.ZodString;
|
|
3370
|
+
ramMib: z.ZodInt;
|
|
3371
|
+
leased: z.ZodBoolean;
|
|
3372
|
+
busy: z.ZodBoolean;
|
|
3373
|
+
}, z.core.$strip>>>>;
|
|
3374
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2733
3375
|
}, z.core.$strip>;
|
|
2734
3376
|
};
|
|
2735
3377
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2764,22 +3406,45 @@ declare const impContract: {
|
|
|
2764
3406
|
requestedBytes: z.ZodInt;
|
|
2765
3407
|
}, z.core.$strip>;
|
|
2766
3408
|
};
|
|
3409
|
+
LEASED: {
|
|
3410
|
+
readonly message: "The imp is leased";
|
|
3411
|
+
readonly status: 409;
|
|
3412
|
+
readonly data: z.ZodObject<{
|
|
3413
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3414
|
+
name: z.ZodString;
|
|
3415
|
+
owner: z.ZodObject<{
|
|
3416
|
+
principal: z.ZodString;
|
|
3417
|
+
display: z.ZodString;
|
|
3418
|
+
label: z.ZodString;
|
|
3419
|
+
}, z.core.$strip>;
|
|
3420
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3421
|
+
}, z.core.$strip>>>;
|
|
3422
|
+
otherCount: z.ZodInt;
|
|
3423
|
+
}, z.core.$strip>;
|
|
3424
|
+
};
|
|
3425
|
+
LEASE_NOT_HELD: {
|
|
3426
|
+
readonly message: "The caller holds no such lease";
|
|
3427
|
+
readonly status: 409;
|
|
3428
|
+
};
|
|
2767
3429
|
AGENT_OUTDATED: {
|
|
2768
3430
|
readonly message: "The imp's agent is too old for this";
|
|
2769
3431
|
readonly status: 409;
|
|
2770
3432
|
};
|
|
2771
3433
|
}>, Record<never, never>>;
|
|
2772
3434
|
};
|
|
2773
|
-
|
|
2774
|
-
|
|
3435
|
+
leases: {
|
|
3436
|
+
acquire: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
2775
3437
|
name: z.ZodString;
|
|
2776
|
-
label: z.
|
|
3438
|
+
label: z.ZodString;
|
|
3439
|
+
ttlSeconds: z.ZodInt;
|
|
2777
3440
|
}, z.core.$strip>, z.ZodObject<{
|
|
2778
|
-
|
|
2779
|
-
|
|
2780
|
-
|
|
2781
|
-
|
|
2782
|
-
|
|
3441
|
+
name: z.ZodString;
|
|
3442
|
+
owner: z.ZodObject<{
|
|
3443
|
+
principal: z.ZodString;
|
|
3444
|
+
display: z.ZodString;
|
|
3445
|
+
label: z.ZodString;
|
|
3446
|
+
}, z.core.$strip>;
|
|
3447
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
2783
3448
|
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
2784
3449
|
NOT_FOUND: {
|
|
2785
3450
|
readonly message: "Not found";
|
|
@@ -2832,6 +3497,14 @@ declare const impContract: {
|
|
|
2832
3497
|
budgetMib: z.ZodInt;
|
|
2833
3498
|
usedMib: z.ZodInt;
|
|
2834
3499
|
requestedMib: z.ZodInt;
|
|
3500
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
3501
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3502
|
+
name: z.ZodString;
|
|
3503
|
+
ramMib: z.ZodInt;
|
|
3504
|
+
leased: z.ZodBoolean;
|
|
3505
|
+
busy: z.ZodBoolean;
|
|
3506
|
+
}, z.core.$strip>>>>;
|
|
3507
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2835
3508
|
}, z.core.$strip>;
|
|
2836
3509
|
};
|
|
2837
3510
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2866,20 +3539,44 @@ declare const impContract: {
|
|
|
2866
3539
|
requestedBytes: z.ZodInt;
|
|
2867
3540
|
}, z.core.$strip>;
|
|
2868
3541
|
};
|
|
3542
|
+
LEASED: {
|
|
3543
|
+
readonly message: "The imp is leased";
|
|
3544
|
+
readonly status: 409;
|
|
3545
|
+
readonly data: z.ZodObject<{
|
|
3546
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3547
|
+
name: z.ZodString;
|
|
3548
|
+
owner: z.ZodObject<{
|
|
3549
|
+
principal: z.ZodString;
|
|
3550
|
+
display: z.ZodString;
|
|
3551
|
+
label: z.ZodString;
|
|
3552
|
+
}, z.core.$strip>;
|
|
3553
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3554
|
+
}, z.core.$strip>>>;
|
|
3555
|
+
otherCount: z.ZodInt;
|
|
3556
|
+
}, z.core.$strip>;
|
|
3557
|
+
};
|
|
3558
|
+
LEASE_NOT_HELD: {
|
|
3559
|
+
readonly message: "The caller holds no such lease";
|
|
3560
|
+
readonly status: 409;
|
|
3561
|
+
};
|
|
2869
3562
|
AGENT_OUTDATED: {
|
|
2870
3563
|
readonly message: "The imp's agent is too old for this";
|
|
2871
3564
|
readonly status: 409;
|
|
2872
3565
|
};
|
|
2873
3566
|
}>, Record<never, never>>;
|
|
2874
|
-
|
|
3567
|
+
renew: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
2875
3568
|
name: z.ZodString;
|
|
2876
|
-
|
|
2877
|
-
|
|
2878
|
-
|
|
2879
|
-
|
|
2880
|
-
|
|
2881
|
-
|
|
2882
|
-
|
|
3569
|
+
label: z.ZodString;
|
|
3570
|
+
ttlSeconds: z.ZodInt;
|
|
3571
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3572
|
+
name: z.ZodString;
|
|
3573
|
+
owner: z.ZodObject<{
|
|
3574
|
+
principal: z.ZodString;
|
|
3575
|
+
display: z.ZodString;
|
|
3576
|
+
label: z.ZodString;
|
|
3577
|
+
}, z.core.$strip>;
|
|
3578
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3579
|
+
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
2883
3580
|
NOT_FOUND: {
|
|
2884
3581
|
readonly message: "Not found";
|
|
2885
3582
|
readonly data: z.ZodObject<{
|
|
@@ -2931,6 +3628,14 @@ declare const impContract: {
|
|
|
2931
3628
|
budgetMib: z.ZodInt;
|
|
2932
3629
|
usedMib: z.ZodInt;
|
|
2933
3630
|
requestedMib: z.ZodInt;
|
|
3631
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
3632
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3633
|
+
name: z.ZodString;
|
|
3634
|
+
ramMib: z.ZodInt;
|
|
3635
|
+
leased: z.ZodBoolean;
|
|
3636
|
+
busy: z.ZodBoolean;
|
|
3637
|
+
}, z.core.$strip>>>>;
|
|
3638
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
2934
3639
|
}, z.core.$strip>;
|
|
2935
3640
|
};
|
|
2936
3641
|
SERVICE_UNAVAILABLE: {
|
|
@@ -2965,28 +3670,559 @@ declare const impContract: {
|
|
|
2965
3670
|
requestedBytes: z.ZodInt;
|
|
2966
3671
|
}, z.core.$strip>;
|
|
2967
3672
|
};
|
|
3673
|
+
LEASED: {
|
|
3674
|
+
readonly message: "The imp is leased";
|
|
3675
|
+
readonly status: 409;
|
|
3676
|
+
readonly data: z.ZodObject<{
|
|
3677
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3678
|
+
name: z.ZodString;
|
|
3679
|
+
owner: z.ZodObject<{
|
|
3680
|
+
principal: z.ZodString;
|
|
3681
|
+
display: z.ZodString;
|
|
3682
|
+
label: z.ZodString;
|
|
3683
|
+
}, z.core.$strip>;
|
|
3684
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3685
|
+
}, z.core.$strip>>>;
|
|
3686
|
+
otherCount: z.ZodInt;
|
|
3687
|
+
}, z.core.$strip>;
|
|
3688
|
+
};
|
|
3689
|
+
LEASE_NOT_HELD: {
|
|
3690
|
+
readonly message: "The caller holds no such lease";
|
|
3691
|
+
readonly status: 409;
|
|
3692
|
+
};
|
|
2968
3693
|
AGENT_OUTDATED: {
|
|
2969
3694
|
readonly message: "The imp's agent is too old for this";
|
|
2970
3695
|
readonly status: 409;
|
|
2971
3696
|
};
|
|
2972
3697
|
}>, Record<never, never>>;
|
|
2973
|
-
|
|
3698
|
+
release: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
2974
3699
|
name: z.ZodString;
|
|
2975
|
-
|
|
3700
|
+
label: z.ZodString;
|
|
2976
3701
|
}, z.core.$strip>, z.ZodObject<{
|
|
2977
|
-
|
|
2978
|
-
|
|
2979
|
-
|
|
2980
|
-
|
|
2981
|
-
|
|
2982
|
-
|
|
2983
|
-
|
|
2984
|
-
|
|
2985
|
-
|
|
2986
|
-
|
|
2987
|
-
|
|
2988
|
-
|
|
2989
|
-
|
|
3702
|
+
released: z.ZodBoolean;
|
|
3703
|
+
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
3704
|
+
NOT_FOUND: {
|
|
3705
|
+
readonly message: "Not found";
|
|
3706
|
+
readonly data: z.ZodObject<{
|
|
3707
|
+
kind: z.ZodEnum<{
|
|
3708
|
+
backup: "backup";
|
|
3709
|
+
checkpoint: "checkpoint";
|
|
3710
|
+
grant: "grant";
|
|
3711
|
+
image: "image";
|
|
3712
|
+
imp: "imp";
|
|
3713
|
+
network: "network";
|
|
3714
|
+
secret: "secret";
|
|
3715
|
+
service: "service";
|
|
3716
|
+
session: "session";
|
|
3717
|
+
"ssh-key": "ssh-key";
|
|
3718
|
+
token: "token";
|
|
3719
|
+
}>;
|
|
3720
|
+
name: z.ZodString;
|
|
3721
|
+
}, z.core.$strip>;
|
|
3722
|
+
};
|
|
3723
|
+
CONFLICT: {
|
|
3724
|
+
readonly message: "Already exists";
|
|
3725
|
+
readonly data: z.ZodObject<{
|
|
3726
|
+
kind: z.ZodEnum<{
|
|
3727
|
+
backup: "backup";
|
|
3728
|
+
checkpoint: "checkpoint";
|
|
3729
|
+
grant: "grant";
|
|
3730
|
+
image: "image";
|
|
3731
|
+
imp: "imp";
|
|
3732
|
+
network: "network";
|
|
3733
|
+
secret: "secret";
|
|
3734
|
+
service: "service";
|
|
3735
|
+
session: "session";
|
|
3736
|
+
"ssh-key": "ssh-key";
|
|
3737
|
+
token: "token";
|
|
3738
|
+
}>;
|
|
3739
|
+
name: z.ZodString;
|
|
3740
|
+
}, z.core.$strip>;
|
|
3741
|
+
};
|
|
3742
|
+
FORBIDDEN: {
|
|
3743
|
+
readonly message: "Not allowed";
|
|
3744
|
+
};
|
|
3745
|
+
PRECONDITION_FAILED: {
|
|
3746
|
+
readonly message: "Not possible on this host";
|
|
3747
|
+
};
|
|
3748
|
+
RAM_BUDGET_EXCEEDED: {
|
|
3749
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
3750
|
+
readonly status: 503;
|
|
3751
|
+
readonly data: z.ZodObject<{
|
|
3752
|
+
budgetMib: z.ZodInt;
|
|
3753
|
+
usedMib: z.ZodInt;
|
|
3754
|
+
requestedMib: z.ZodInt;
|
|
3755
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
3756
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3757
|
+
name: z.ZodString;
|
|
3758
|
+
ramMib: z.ZodInt;
|
|
3759
|
+
leased: z.ZodBoolean;
|
|
3760
|
+
busy: z.ZodBoolean;
|
|
3761
|
+
}, z.core.$strip>>>>;
|
|
3762
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3763
|
+
}, z.core.$strip>;
|
|
3764
|
+
};
|
|
3765
|
+
SERVICE_UNAVAILABLE: {
|
|
3766
|
+
readonly message: "impd is stopping";
|
|
3767
|
+
};
|
|
3768
|
+
INVALID_STATE: {
|
|
3769
|
+
readonly message: "The imp is not in a state that allows this";
|
|
3770
|
+
readonly status: 409;
|
|
3771
|
+
readonly data: z.ZodObject<{
|
|
3772
|
+
state: z.ZodEnum<{
|
|
3773
|
+
creating: "creating";
|
|
3774
|
+
error: "error";
|
|
3775
|
+
running: "running";
|
|
3776
|
+
sleeping: "sleeping";
|
|
3777
|
+
stopped: "stopped";
|
|
3778
|
+
}>;
|
|
3779
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
3780
|
+
creating: "creating";
|
|
3781
|
+
error: "error";
|
|
3782
|
+
running: "running";
|
|
3783
|
+
sleeping: "sleeping";
|
|
3784
|
+
stopped: "stopped";
|
|
3785
|
+
}>>;
|
|
3786
|
+
}, z.core.$strip>;
|
|
3787
|
+
};
|
|
3788
|
+
DISK_FULL: {
|
|
3789
|
+
readonly message: "Not enough free disk on the host";
|
|
3790
|
+
readonly status: 507;
|
|
3791
|
+
readonly data: z.ZodObject<{
|
|
3792
|
+
availableBytes: z.ZodInt;
|
|
3793
|
+
reserveBytes: z.ZodInt;
|
|
3794
|
+
requestedBytes: z.ZodInt;
|
|
3795
|
+
}, z.core.$strip>;
|
|
3796
|
+
};
|
|
3797
|
+
LEASED: {
|
|
3798
|
+
readonly message: "The imp is leased";
|
|
3799
|
+
readonly status: 409;
|
|
3800
|
+
readonly data: z.ZodObject<{
|
|
3801
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3802
|
+
name: z.ZodString;
|
|
3803
|
+
owner: z.ZodObject<{
|
|
3804
|
+
principal: z.ZodString;
|
|
3805
|
+
display: z.ZodString;
|
|
3806
|
+
label: z.ZodString;
|
|
3807
|
+
}, z.core.$strip>;
|
|
3808
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3809
|
+
}, z.core.$strip>>>;
|
|
3810
|
+
otherCount: z.ZodInt;
|
|
3811
|
+
}, z.core.$strip>;
|
|
3812
|
+
};
|
|
3813
|
+
LEASE_NOT_HELD: {
|
|
3814
|
+
readonly message: "The caller holds no such lease";
|
|
3815
|
+
readonly status: 409;
|
|
3816
|
+
};
|
|
3817
|
+
AGENT_OUTDATED: {
|
|
3818
|
+
readonly message: "The imp's agent is too old for this";
|
|
3819
|
+
readonly status: 409;
|
|
3820
|
+
};
|
|
3821
|
+
}>, Record<never, never>>;
|
|
3822
|
+
list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
3823
|
+
name: z.ZodOptional<z.ZodString>;
|
|
3824
|
+
label: z.ZodOptional<z.ZodString>;
|
|
3825
|
+
}, z.core.$strip>, z.ZodArray<z.ZodObject<{
|
|
3826
|
+
name: z.ZodString;
|
|
3827
|
+
owner: z.ZodObject<{
|
|
3828
|
+
principal: z.ZodString;
|
|
3829
|
+
display: z.ZodString;
|
|
3830
|
+
label: z.ZodString;
|
|
3831
|
+
}, z.core.$strip>;
|
|
3832
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3833
|
+
}, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
3834
|
+
NOT_FOUND: {
|
|
3835
|
+
readonly message: "Not found";
|
|
3836
|
+
readonly data: z.ZodObject<{
|
|
3837
|
+
kind: z.ZodEnum<{
|
|
3838
|
+
backup: "backup";
|
|
3839
|
+
checkpoint: "checkpoint";
|
|
3840
|
+
grant: "grant";
|
|
3841
|
+
image: "image";
|
|
3842
|
+
imp: "imp";
|
|
3843
|
+
network: "network";
|
|
3844
|
+
secret: "secret";
|
|
3845
|
+
service: "service";
|
|
3846
|
+
session: "session";
|
|
3847
|
+
"ssh-key": "ssh-key";
|
|
3848
|
+
token: "token";
|
|
3849
|
+
}>;
|
|
3850
|
+
name: z.ZodString;
|
|
3851
|
+
}, z.core.$strip>;
|
|
3852
|
+
};
|
|
3853
|
+
CONFLICT: {
|
|
3854
|
+
readonly message: "Already exists";
|
|
3855
|
+
readonly data: z.ZodObject<{
|
|
3856
|
+
kind: z.ZodEnum<{
|
|
3857
|
+
backup: "backup";
|
|
3858
|
+
checkpoint: "checkpoint";
|
|
3859
|
+
grant: "grant";
|
|
3860
|
+
image: "image";
|
|
3861
|
+
imp: "imp";
|
|
3862
|
+
network: "network";
|
|
3863
|
+
secret: "secret";
|
|
3864
|
+
service: "service";
|
|
3865
|
+
session: "session";
|
|
3866
|
+
"ssh-key": "ssh-key";
|
|
3867
|
+
token: "token";
|
|
3868
|
+
}>;
|
|
3869
|
+
name: z.ZodString;
|
|
3870
|
+
}, z.core.$strip>;
|
|
3871
|
+
};
|
|
3872
|
+
FORBIDDEN: {
|
|
3873
|
+
readonly message: "Not allowed";
|
|
3874
|
+
};
|
|
3875
|
+
PRECONDITION_FAILED: {
|
|
3876
|
+
readonly message: "Not possible on this host";
|
|
3877
|
+
};
|
|
3878
|
+
RAM_BUDGET_EXCEEDED: {
|
|
3879
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
3880
|
+
readonly status: 503;
|
|
3881
|
+
readonly data: z.ZodObject<{
|
|
3882
|
+
budgetMib: z.ZodInt;
|
|
3883
|
+
usedMib: z.ZodInt;
|
|
3884
|
+
requestedMib: z.ZodInt;
|
|
3885
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
3886
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3887
|
+
name: z.ZodString;
|
|
3888
|
+
ramMib: z.ZodInt;
|
|
3889
|
+
leased: z.ZodBoolean;
|
|
3890
|
+
busy: z.ZodBoolean;
|
|
3891
|
+
}, z.core.$strip>>>>;
|
|
3892
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3893
|
+
}, z.core.$strip>;
|
|
3894
|
+
};
|
|
3895
|
+
SERVICE_UNAVAILABLE: {
|
|
3896
|
+
readonly message: "impd is stopping";
|
|
3897
|
+
};
|
|
3898
|
+
INVALID_STATE: {
|
|
3899
|
+
readonly message: "The imp is not in a state that allows this";
|
|
3900
|
+
readonly status: 409;
|
|
3901
|
+
readonly data: z.ZodObject<{
|
|
3902
|
+
state: z.ZodEnum<{
|
|
3903
|
+
creating: "creating";
|
|
3904
|
+
error: "error";
|
|
3905
|
+
running: "running";
|
|
3906
|
+
sleeping: "sleeping";
|
|
3907
|
+
stopped: "stopped";
|
|
3908
|
+
}>;
|
|
3909
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
3910
|
+
creating: "creating";
|
|
3911
|
+
error: "error";
|
|
3912
|
+
running: "running";
|
|
3913
|
+
sleeping: "sleeping";
|
|
3914
|
+
stopped: "stopped";
|
|
3915
|
+
}>>;
|
|
3916
|
+
}, z.core.$strip>;
|
|
3917
|
+
};
|
|
3918
|
+
DISK_FULL: {
|
|
3919
|
+
readonly message: "Not enough free disk on the host";
|
|
3920
|
+
readonly status: 507;
|
|
3921
|
+
readonly data: z.ZodObject<{
|
|
3922
|
+
availableBytes: z.ZodInt;
|
|
3923
|
+
reserveBytes: z.ZodInt;
|
|
3924
|
+
requestedBytes: z.ZodInt;
|
|
3925
|
+
}, z.core.$strip>;
|
|
3926
|
+
};
|
|
3927
|
+
LEASED: {
|
|
3928
|
+
readonly message: "The imp is leased";
|
|
3929
|
+
readonly status: 409;
|
|
3930
|
+
readonly data: z.ZodObject<{
|
|
3931
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
3932
|
+
name: z.ZodString;
|
|
3933
|
+
owner: z.ZodObject<{
|
|
3934
|
+
principal: z.ZodString;
|
|
3935
|
+
display: z.ZodString;
|
|
3936
|
+
label: z.ZodString;
|
|
3937
|
+
}, z.core.$strip>;
|
|
3938
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
3939
|
+
}, z.core.$strip>>>;
|
|
3940
|
+
otherCount: z.ZodInt;
|
|
3941
|
+
}, z.core.$strip>;
|
|
3942
|
+
};
|
|
3943
|
+
LEASE_NOT_HELD: {
|
|
3944
|
+
readonly message: "The caller holds no such lease";
|
|
3945
|
+
readonly status: 409;
|
|
3946
|
+
};
|
|
3947
|
+
AGENT_OUTDATED: {
|
|
3948
|
+
readonly message: "The imp's agent is too old for this";
|
|
3949
|
+
readonly status: 409;
|
|
3950
|
+
};
|
|
3951
|
+
}>, Record<never, never>>;
|
|
3952
|
+
};
|
|
3953
|
+
checkpoints: {
|
|
3954
|
+
create: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
3955
|
+
name: z.ZodString;
|
|
3956
|
+
label: z.ZodOptional<z.ZodString>;
|
|
3957
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
3958
|
+
id: z.ZodString;
|
|
3959
|
+
label: z.ZodOptional<z.ZodString>;
|
|
3960
|
+
createdAt: z.ZodDate;
|
|
3961
|
+
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
3962
|
+
diskMib: z.ZodInt;
|
|
3963
|
+
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
3964
|
+
NOT_FOUND: {
|
|
3965
|
+
readonly message: "Not found";
|
|
3966
|
+
readonly data: z.ZodObject<{
|
|
3967
|
+
kind: z.ZodEnum<{
|
|
3968
|
+
backup: "backup";
|
|
3969
|
+
checkpoint: "checkpoint";
|
|
3970
|
+
grant: "grant";
|
|
3971
|
+
image: "image";
|
|
3972
|
+
imp: "imp";
|
|
3973
|
+
network: "network";
|
|
3974
|
+
secret: "secret";
|
|
3975
|
+
service: "service";
|
|
3976
|
+
session: "session";
|
|
3977
|
+
"ssh-key": "ssh-key";
|
|
3978
|
+
token: "token";
|
|
3979
|
+
}>;
|
|
3980
|
+
name: z.ZodString;
|
|
3981
|
+
}, z.core.$strip>;
|
|
3982
|
+
};
|
|
3983
|
+
CONFLICT: {
|
|
3984
|
+
readonly message: "Already exists";
|
|
3985
|
+
readonly data: z.ZodObject<{
|
|
3986
|
+
kind: z.ZodEnum<{
|
|
3987
|
+
backup: "backup";
|
|
3988
|
+
checkpoint: "checkpoint";
|
|
3989
|
+
grant: "grant";
|
|
3990
|
+
image: "image";
|
|
3991
|
+
imp: "imp";
|
|
3992
|
+
network: "network";
|
|
3993
|
+
secret: "secret";
|
|
3994
|
+
service: "service";
|
|
3995
|
+
session: "session";
|
|
3996
|
+
"ssh-key": "ssh-key";
|
|
3997
|
+
token: "token";
|
|
3998
|
+
}>;
|
|
3999
|
+
name: z.ZodString;
|
|
4000
|
+
}, z.core.$strip>;
|
|
4001
|
+
};
|
|
4002
|
+
FORBIDDEN: {
|
|
4003
|
+
readonly message: "Not allowed";
|
|
4004
|
+
};
|
|
4005
|
+
PRECONDITION_FAILED: {
|
|
4006
|
+
readonly message: "Not possible on this host";
|
|
4007
|
+
};
|
|
4008
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4009
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4010
|
+
readonly status: 503;
|
|
4011
|
+
readonly data: z.ZodObject<{
|
|
4012
|
+
budgetMib: z.ZodInt;
|
|
4013
|
+
usedMib: z.ZodInt;
|
|
4014
|
+
requestedMib: z.ZodInt;
|
|
4015
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4016
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4017
|
+
name: z.ZodString;
|
|
4018
|
+
ramMib: z.ZodInt;
|
|
4019
|
+
leased: z.ZodBoolean;
|
|
4020
|
+
busy: z.ZodBoolean;
|
|
4021
|
+
}, z.core.$strip>>>>;
|
|
4022
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4023
|
+
}, z.core.$strip>;
|
|
4024
|
+
};
|
|
4025
|
+
SERVICE_UNAVAILABLE: {
|
|
4026
|
+
readonly message: "impd is stopping";
|
|
4027
|
+
};
|
|
4028
|
+
INVALID_STATE: {
|
|
4029
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4030
|
+
readonly status: 409;
|
|
4031
|
+
readonly data: z.ZodObject<{
|
|
4032
|
+
state: z.ZodEnum<{
|
|
4033
|
+
creating: "creating";
|
|
4034
|
+
error: "error";
|
|
4035
|
+
running: "running";
|
|
4036
|
+
sleeping: "sleeping";
|
|
4037
|
+
stopped: "stopped";
|
|
4038
|
+
}>;
|
|
4039
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4040
|
+
creating: "creating";
|
|
4041
|
+
error: "error";
|
|
4042
|
+
running: "running";
|
|
4043
|
+
sleeping: "sleeping";
|
|
4044
|
+
stopped: "stopped";
|
|
4045
|
+
}>>;
|
|
4046
|
+
}, z.core.$strip>;
|
|
4047
|
+
};
|
|
4048
|
+
DISK_FULL: {
|
|
4049
|
+
readonly message: "Not enough free disk on the host";
|
|
4050
|
+
readonly status: 507;
|
|
4051
|
+
readonly data: z.ZodObject<{
|
|
4052
|
+
availableBytes: z.ZodInt;
|
|
4053
|
+
reserveBytes: z.ZodInt;
|
|
4054
|
+
requestedBytes: z.ZodInt;
|
|
4055
|
+
}, z.core.$strip>;
|
|
4056
|
+
};
|
|
4057
|
+
LEASED: {
|
|
4058
|
+
readonly message: "The imp is leased";
|
|
4059
|
+
readonly status: 409;
|
|
4060
|
+
readonly data: z.ZodObject<{
|
|
4061
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4062
|
+
name: z.ZodString;
|
|
4063
|
+
owner: z.ZodObject<{
|
|
4064
|
+
principal: z.ZodString;
|
|
4065
|
+
display: z.ZodString;
|
|
4066
|
+
label: z.ZodString;
|
|
4067
|
+
}, z.core.$strip>;
|
|
4068
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4069
|
+
}, z.core.$strip>>>;
|
|
4070
|
+
otherCount: z.ZodInt;
|
|
4071
|
+
}, z.core.$strip>;
|
|
4072
|
+
};
|
|
4073
|
+
LEASE_NOT_HELD: {
|
|
4074
|
+
readonly message: "The caller holds no such lease";
|
|
4075
|
+
readonly status: 409;
|
|
4076
|
+
};
|
|
4077
|
+
AGENT_OUTDATED: {
|
|
4078
|
+
readonly message: "The imp's agent is too old for this";
|
|
4079
|
+
readonly status: 409;
|
|
4080
|
+
};
|
|
4081
|
+
}>, Record<never, never>>;
|
|
4082
|
+
list: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
4083
|
+
name: z.ZodString;
|
|
4084
|
+
}, z.core.$strip>, z.ZodArray<z.ZodObject<{
|
|
4085
|
+
id: z.ZodString;
|
|
4086
|
+
label: z.ZodOptional<z.ZodString>;
|
|
4087
|
+
createdAt: z.ZodDate;
|
|
4088
|
+
sizeBytes: z.ZodOptional<z.ZodInt>;
|
|
4089
|
+
diskMib: z.ZodInt;
|
|
4090
|
+
}, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
4091
|
+
NOT_FOUND: {
|
|
4092
|
+
readonly message: "Not found";
|
|
4093
|
+
readonly data: z.ZodObject<{
|
|
4094
|
+
kind: z.ZodEnum<{
|
|
4095
|
+
backup: "backup";
|
|
4096
|
+
checkpoint: "checkpoint";
|
|
4097
|
+
grant: "grant";
|
|
4098
|
+
image: "image";
|
|
4099
|
+
imp: "imp";
|
|
4100
|
+
network: "network";
|
|
4101
|
+
secret: "secret";
|
|
4102
|
+
service: "service";
|
|
4103
|
+
session: "session";
|
|
4104
|
+
"ssh-key": "ssh-key";
|
|
4105
|
+
token: "token";
|
|
4106
|
+
}>;
|
|
4107
|
+
name: z.ZodString;
|
|
4108
|
+
}, z.core.$strip>;
|
|
4109
|
+
};
|
|
4110
|
+
CONFLICT: {
|
|
4111
|
+
readonly message: "Already exists";
|
|
4112
|
+
readonly data: z.ZodObject<{
|
|
4113
|
+
kind: z.ZodEnum<{
|
|
4114
|
+
backup: "backup";
|
|
4115
|
+
checkpoint: "checkpoint";
|
|
4116
|
+
grant: "grant";
|
|
4117
|
+
image: "image";
|
|
4118
|
+
imp: "imp";
|
|
4119
|
+
network: "network";
|
|
4120
|
+
secret: "secret";
|
|
4121
|
+
service: "service";
|
|
4122
|
+
session: "session";
|
|
4123
|
+
"ssh-key": "ssh-key";
|
|
4124
|
+
token: "token";
|
|
4125
|
+
}>;
|
|
4126
|
+
name: z.ZodString;
|
|
4127
|
+
}, z.core.$strip>;
|
|
4128
|
+
};
|
|
4129
|
+
FORBIDDEN: {
|
|
4130
|
+
readonly message: "Not allowed";
|
|
4131
|
+
};
|
|
4132
|
+
PRECONDITION_FAILED: {
|
|
4133
|
+
readonly message: "Not possible on this host";
|
|
4134
|
+
};
|
|
4135
|
+
RAM_BUDGET_EXCEEDED: {
|
|
4136
|
+
readonly message: "Not enough RAM budget, even after sleeping idle imps";
|
|
4137
|
+
readonly status: 503;
|
|
4138
|
+
readonly data: z.ZodObject<{
|
|
4139
|
+
budgetMib: z.ZodInt;
|
|
4140
|
+
usedMib: z.ZodInt;
|
|
4141
|
+
requestedMib: z.ZodInt;
|
|
4142
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4143
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4144
|
+
name: z.ZodString;
|
|
4145
|
+
ramMib: z.ZodInt;
|
|
4146
|
+
leased: z.ZodBoolean;
|
|
4147
|
+
busy: z.ZodBoolean;
|
|
4148
|
+
}, z.core.$strip>>>>;
|
|
4149
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4150
|
+
}, z.core.$strip>;
|
|
4151
|
+
};
|
|
4152
|
+
SERVICE_UNAVAILABLE: {
|
|
4153
|
+
readonly message: "impd is stopping";
|
|
4154
|
+
};
|
|
4155
|
+
INVALID_STATE: {
|
|
4156
|
+
readonly message: "The imp is not in a state that allows this";
|
|
4157
|
+
readonly status: 409;
|
|
4158
|
+
readonly data: z.ZodObject<{
|
|
4159
|
+
state: z.ZodEnum<{
|
|
4160
|
+
creating: "creating";
|
|
4161
|
+
error: "error";
|
|
4162
|
+
running: "running";
|
|
4163
|
+
sleeping: "sleeping";
|
|
4164
|
+
stopped: "stopped";
|
|
4165
|
+
}>;
|
|
4166
|
+
allowed: z.ZodArray<z.ZodEnum<{
|
|
4167
|
+
creating: "creating";
|
|
4168
|
+
error: "error";
|
|
4169
|
+
running: "running";
|
|
4170
|
+
sleeping: "sleeping";
|
|
4171
|
+
stopped: "stopped";
|
|
4172
|
+
}>>;
|
|
4173
|
+
}, z.core.$strip>;
|
|
4174
|
+
};
|
|
4175
|
+
DISK_FULL: {
|
|
4176
|
+
readonly message: "Not enough free disk on the host";
|
|
4177
|
+
readonly status: 507;
|
|
4178
|
+
readonly data: z.ZodObject<{
|
|
4179
|
+
availableBytes: z.ZodInt;
|
|
4180
|
+
reserveBytes: z.ZodInt;
|
|
4181
|
+
requestedBytes: z.ZodInt;
|
|
4182
|
+
}, z.core.$strip>;
|
|
4183
|
+
};
|
|
4184
|
+
LEASED: {
|
|
4185
|
+
readonly message: "The imp is leased";
|
|
4186
|
+
readonly status: 409;
|
|
4187
|
+
readonly data: z.ZodObject<{
|
|
4188
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4189
|
+
name: z.ZodString;
|
|
4190
|
+
owner: z.ZodObject<{
|
|
4191
|
+
principal: z.ZodString;
|
|
4192
|
+
display: z.ZodString;
|
|
4193
|
+
label: z.ZodString;
|
|
4194
|
+
}, z.core.$strip>;
|
|
4195
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4196
|
+
}, z.core.$strip>>>;
|
|
4197
|
+
otherCount: z.ZodInt;
|
|
4198
|
+
}, z.core.$strip>;
|
|
4199
|
+
};
|
|
4200
|
+
LEASE_NOT_HELD: {
|
|
4201
|
+
readonly message: "The caller holds no such lease";
|
|
4202
|
+
readonly status: 409;
|
|
4203
|
+
};
|
|
4204
|
+
AGENT_OUTDATED: {
|
|
4205
|
+
readonly message: "The imp's agent is too old for this";
|
|
4206
|
+
readonly status: 409;
|
|
4207
|
+
};
|
|
4208
|
+
}>, Record<never, never>>;
|
|
4209
|
+
restore: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
4210
|
+
name: z.ZodString;
|
|
4211
|
+
checkpoint: z.ZodString;
|
|
4212
|
+
}, z.core.$strip>, z.ZodObject<{
|
|
4213
|
+
id: z.ZodString;
|
|
4214
|
+
name: z.ZodString;
|
|
4215
|
+
image: z.ZodString;
|
|
4216
|
+
state: z.ZodEnum<{
|
|
4217
|
+
creating: "creating";
|
|
4218
|
+
error: "error";
|
|
4219
|
+
running: "running";
|
|
4220
|
+
sleeping: "sleeping";
|
|
4221
|
+
stopped: "stopped";
|
|
4222
|
+
}>;
|
|
4223
|
+
vcpus: z.ZodInt;
|
|
4224
|
+
memoryMib: z.ZodInt;
|
|
4225
|
+
diskMib: z.ZodInt;
|
|
2990
4226
|
diskUsage: z.ZodOptional<z.ZodObject<{
|
|
2991
4227
|
exclusiveBytes: z.ZodInt;
|
|
2992
4228
|
sharedBytes: z.ZodInt;
|
|
@@ -3012,6 +4248,18 @@ declare const impContract: {
|
|
|
3012
4248
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
3013
4249
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
3014
4250
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
4251
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
4252
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4253
|
+
name: z.ZodString;
|
|
4254
|
+
owner: z.ZodObject<{
|
|
4255
|
+
principal: z.ZodString;
|
|
4256
|
+
display: z.ZodString;
|
|
4257
|
+
label: z.ZodString;
|
|
4258
|
+
}, z.core.$strip>;
|
|
4259
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4260
|
+
}, z.core.$strip>>>;
|
|
4261
|
+
otherCount: z.ZodInt;
|
|
4262
|
+
}, z.core.$strip>>;
|
|
3015
4263
|
error: z.ZodOptional<z.ZodString>;
|
|
3016
4264
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
3017
4265
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -3091,6 +4339,14 @@ declare const impContract: {
|
|
|
3091
4339
|
budgetMib: z.ZodInt;
|
|
3092
4340
|
usedMib: z.ZodInt;
|
|
3093
4341
|
requestedMib: z.ZodInt;
|
|
4342
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4343
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4344
|
+
name: z.ZodString;
|
|
4345
|
+
ramMib: z.ZodInt;
|
|
4346
|
+
leased: z.ZodBoolean;
|
|
4347
|
+
busy: z.ZodBoolean;
|
|
4348
|
+
}, z.core.$strip>>>>;
|
|
4349
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3094
4350
|
}, z.core.$strip>;
|
|
3095
4351
|
};
|
|
3096
4352
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3125,6 +4381,26 @@ declare const impContract: {
|
|
|
3125
4381
|
requestedBytes: z.ZodInt;
|
|
3126
4382
|
}, z.core.$strip>;
|
|
3127
4383
|
};
|
|
4384
|
+
LEASED: {
|
|
4385
|
+
readonly message: "The imp is leased";
|
|
4386
|
+
readonly status: 409;
|
|
4387
|
+
readonly data: z.ZodObject<{
|
|
4388
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4389
|
+
name: z.ZodString;
|
|
4390
|
+
owner: z.ZodObject<{
|
|
4391
|
+
principal: z.ZodString;
|
|
4392
|
+
display: z.ZodString;
|
|
4393
|
+
label: z.ZodString;
|
|
4394
|
+
}, z.core.$strip>;
|
|
4395
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4396
|
+
}, z.core.$strip>>>;
|
|
4397
|
+
otherCount: z.ZodInt;
|
|
4398
|
+
}, z.core.$strip>;
|
|
4399
|
+
};
|
|
4400
|
+
LEASE_NOT_HELD: {
|
|
4401
|
+
readonly message: "The caller holds no such lease";
|
|
4402
|
+
readonly status: 409;
|
|
4403
|
+
};
|
|
3128
4404
|
AGENT_OUTDATED: {
|
|
3129
4405
|
readonly message: "The imp's agent is too old for this";
|
|
3130
4406
|
readonly status: 409;
|
|
@@ -3185,6 +4461,14 @@ declare const impContract: {
|
|
|
3185
4461
|
budgetMib: z.ZodInt;
|
|
3186
4462
|
usedMib: z.ZodInt;
|
|
3187
4463
|
requestedMib: z.ZodInt;
|
|
4464
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4465
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4466
|
+
name: z.ZodString;
|
|
4467
|
+
ramMib: z.ZodInt;
|
|
4468
|
+
leased: z.ZodBoolean;
|
|
4469
|
+
busy: z.ZodBoolean;
|
|
4470
|
+
}, z.core.$strip>>>>;
|
|
4471
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3188
4472
|
}, z.core.$strip>;
|
|
3189
4473
|
};
|
|
3190
4474
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3219,6 +4503,26 @@ declare const impContract: {
|
|
|
3219
4503
|
requestedBytes: z.ZodInt;
|
|
3220
4504
|
}, z.core.$strip>;
|
|
3221
4505
|
};
|
|
4506
|
+
LEASED: {
|
|
4507
|
+
readonly message: "The imp is leased";
|
|
4508
|
+
readonly status: 409;
|
|
4509
|
+
readonly data: z.ZodObject<{
|
|
4510
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4511
|
+
name: z.ZodString;
|
|
4512
|
+
owner: z.ZodObject<{
|
|
4513
|
+
principal: z.ZodString;
|
|
4514
|
+
display: z.ZodString;
|
|
4515
|
+
label: z.ZodString;
|
|
4516
|
+
}, z.core.$strip>;
|
|
4517
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4518
|
+
}, z.core.$strip>>>;
|
|
4519
|
+
otherCount: z.ZodInt;
|
|
4520
|
+
}, z.core.$strip>;
|
|
4521
|
+
};
|
|
4522
|
+
LEASE_NOT_HELD: {
|
|
4523
|
+
readonly message: "The caller holds no such lease";
|
|
4524
|
+
readonly status: 409;
|
|
4525
|
+
};
|
|
3222
4526
|
AGENT_OUTDATED: {
|
|
3223
4527
|
readonly message: "The imp's agent is too old for this";
|
|
3224
4528
|
readonly status: 409;
|
|
@@ -3287,6 +4591,14 @@ declare const impContract: {
|
|
|
3287
4591
|
budgetMib: z.ZodInt;
|
|
3288
4592
|
usedMib: z.ZodInt;
|
|
3289
4593
|
requestedMib: z.ZodInt;
|
|
4594
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4595
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4596
|
+
name: z.ZodString;
|
|
4597
|
+
ramMib: z.ZodInt;
|
|
4598
|
+
leased: z.ZodBoolean;
|
|
4599
|
+
busy: z.ZodBoolean;
|
|
4600
|
+
}, z.core.$strip>>>>;
|
|
4601
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3290
4602
|
}, z.core.$strip>;
|
|
3291
4603
|
};
|
|
3292
4604
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3321,6 +4633,26 @@ declare const impContract: {
|
|
|
3321
4633
|
requestedBytes: z.ZodInt;
|
|
3322
4634
|
}, z.core.$strip>;
|
|
3323
4635
|
};
|
|
4636
|
+
LEASED: {
|
|
4637
|
+
readonly message: "The imp is leased";
|
|
4638
|
+
readonly status: 409;
|
|
4639
|
+
readonly data: z.ZodObject<{
|
|
4640
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4641
|
+
name: z.ZodString;
|
|
4642
|
+
owner: z.ZodObject<{
|
|
4643
|
+
principal: z.ZodString;
|
|
4644
|
+
display: z.ZodString;
|
|
4645
|
+
label: z.ZodString;
|
|
4646
|
+
}, z.core.$strip>;
|
|
4647
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4648
|
+
}, z.core.$strip>>>;
|
|
4649
|
+
otherCount: z.ZodInt;
|
|
4650
|
+
}, z.core.$strip>;
|
|
4651
|
+
};
|
|
4652
|
+
LEASE_NOT_HELD: {
|
|
4653
|
+
readonly message: "The caller holds no such lease";
|
|
4654
|
+
readonly status: 409;
|
|
4655
|
+
};
|
|
3324
4656
|
AGENT_OUTDATED: {
|
|
3325
4657
|
readonly message: "The imp's agent is too old for this";
|
|
3326
4658
|
readonly status: 409;
|
|
@@ -3390,6 +4722,14 @@ declare const impContract: {
|
|
|
3390
4722
|
budgetMib: z.ZodInt;
|
|
3391
4723
|
usedMib: z.ZodInt;
|
|
3392
4724
|
requestedMib: z.ZodInt;
|
|
4725
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4726
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4727
|
+
name: z.ZodString;
|
|
4728
|
+
ramMib: z.ZodInt;
|
|
4729
|
+
leased: z.ZodBoolean;
|
|
4730
|
+
busy: z.ZodBoolean;
|
|
4731
|
+
}, z.core.$strip>>>>;
|
|
4732
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3393
4733
|
}, z.core.$strip>;
|
|
3394
4734
|
};
|
|
3395
4735
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3424,6 +4764,26 @@ declare const impContract: {
|
|
|
3424
4764
|
requestedBytes: z.ZodInt;
|
|
3425
4765
|
}, z.core.$strip>;
|
|
3426
4766
|
};
|
|
4767
|
+
LEASED: {
|
|
4768
|
+
readonly message: "The imp is leased";
|
|
4769
|
+
readonly status: 409;
|
|
4770
|
+
readonly data: z.ZodObject<{
|
|
4771
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4772
|
+
name: z.ZodString;
|
|
4773
|
+
owner: z.ZodObject<{
|
|
4774
|
+
principal: z.ZodString;
|
|
4775
|
+
display: z.ZodString;
|
|
4776
|
+
label: z.ZodString;
|
|
4777
|
+
}, z.core.$strip>;
|
|
4778
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4779
|
+
}, z.core.$strip>>>;
|
|
4780
|
+
otherCount: z.ZodInt;
|
|
4781
|
+
}, z.core.$strip>;
|
|
4782
|
+
};
|
|
4783
|
+
LEASE_NOT_HELD: {
|
|
4784
|
+
readonly message: "The caller holds no such lease";
|
|
4785
|
+
readonly status: 409;
|
|
4786
|
+
};
|
|
3427
4787
|
AGENT_OUTDATED: {
|
|
3428
4788
|
readonly message: "The imp's agent is too old for this";
|
|
3429
4789
|
readonly status: 409;
|
|
@@ -3475,6 +4835,18 @@ declare const impContract: {
|
|
|
3475
4835
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
3476
4836
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
3477
4837
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
4838
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
4839
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4840
|
+
name: z.ZodString;
|
|
4841
|
+
owner: z.ZodObject<{
|
|
4842
|
+
principal: z.ZodString;
|
|
4843
|
+
display: z.ZodString;
|
|
4844
|
+
label: z.ZodString;
|
|
4845
|
+
}, z.core.$strip>;
|
|
4846
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4847
|
+
}, z.core.$strip>>>;
|
|
4848
|
+
otherCount: z.ZodInt;
|
|
4849
|
+
}, z.core.$strip>>;
|
|
3478
4850
|
error: z.ZodOptional<z.ZodString>;
|
|
3479
4851
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
3480
4852
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -3560,6 +4932,14 @@ declare const impContract: {
|
|
|
3560
4932
|
budgetMib: z.ZodInt;
|
|
3561
4933
|
usedMib: z.ZodInt;
|
|
3562
4934
|
requestedMib: z.ZodInt;
|
|
4935
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
4936
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4937
|
+
name: z.ZodString;
|
|
4938
|
+
ramMib: z.ZodInt;
|
|
4939
|
+
leased: z.ZodBoolean;
|
|
4940
|
+
busy: z.ZodBoolean;
|
|
4941
|
+
}, z.core.$strip>>>>;
|
|
4942
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3563
4943
|
}, z.core.$strip>;
|
|
3564
4944
|
};
|
|
3565
4945
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3594,6 +4974,26 @@ declare const impContract: {
|
|
|
3594
4974
|
requestedBytes: z.ZodInt;
|
|
3595
4975
|
}, z.core.$strip>;
|
|
3596
4976
|
};
|
|
4977
|
+
LEASED: {
|
|
4978
|
+
readonly message: "The imp is leased";
|
|
4979
|
+
readonly status: 409;
|
|
4980
|
+
readonly data: z.ZodObject<{
|
|
4981
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
4982
|
+
name: z.ZodString;
|
|
4983
|
+
owner: z.ZodObject<{
|
|
4984
|
+
principal: z.ZodString;
|
|
4985
|
+
display: z.ZodString;
|
|
4986
|
+
label: z.ZodString;
|
|
4987
|
+
}, z.core.$strip>;
|
|
4988
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
4989
|
+
}, z.core.$strip>>>;
|
|
4990
|
+
otherCount: z.ZodInt;
|
|
4991
|
+
}, z.core.$strip>;
|
|
4992
|
+
};
|
|
4993
|
+
LEASE_NOT_HELD: {
|
|
4994
|
+
readonly message: "The caller holds no such lease";
|
|
4995
|
+
readonly status: 409;
|
|
4996
|
+
};
|
|
3597
4997
|
AGENT_OUTDATED: {
|
|
3598
4998
|
readonly message: "The imp's agent is too old for this";
|
|
3599
4999
|
readonly status: 409;
|
|
@@ -3653,6 +5053,14 @@ declare const impContract: {
|
|
|
3653
5053
|
budgetMib: z.ZodInt;
|
|
3654
5054
|
usedMib: z.ZodInt;
|
|
3655
5055
|
requestedMib: z.ZodInt;
|
|
5056
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5057
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5058
|
+
name: z.ZodString;
|
|
5059
|
+
ramMib: z.ZodInt;
|
|
5060
|
+
leased: z.ZodBoolean;
|
|
5061
|
+
busy: z.ZodBoolean;
|
|
5062
|
+
}, z.core.$strip>>>>;
|
|
5063
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3656
5064
|
}, z.core.$strip>;
|
|
3657
5065
|
};
|
|
3658
5066
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3687,6 +5095,26 @@ declare const impContract: {
|
|
|
3687
5095
|
requestedBytes: z.ZodInt;
|
|
3688
5096
|
}, z.core.$strip>;
|
|
3689
5097
|
};
|
|
5098
|
+
LEASED: {
|
|
5099
|
+
readonly message: "The imp is leased";
|
|
5100
|
+
readonly status: 409;
|
|
5101
|
+
readonly data: z.ZodObject<{
|
|
5102
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5103
|
+
name: z.ZodString;
|
|
5104
|
+
owner: z.ZodObject<{
|
|
5105
|
+
principal: z.ZodString;
|
|
5106
|
+
display: z.ZodString;
|
|
5107
|
+
label: z.ZodString;
|
|
5108
|
+
}, z.core.$strip>;
|
|
5109
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5110
|
+
}, z.core.$strip>>>;
|
|
5111
|
+
otherCount: z.ZodInt;
|
|
5112
|
+
}, z.core.$strip>;
|
|
5113
|
+
};
|
|
5114
|
+
LEASE_NOT_HELD: {
|
|
5115
|
+
readonly message: "The caller holds no such lease";
|
|
5116
|
+
readonly status: 409;
|
|
5117
|
+
};
|
|
3690
5118
|
AGENT_OUTDATED: {
|
|
3691
5119
|
readonly message: "The imp's agent is too old for this";
|
|
3692
5120
|
readonly status: 409;
|
|
@@ -3757,6 +5185,14 @@ declare const impContract: {
|
|
|
3757
5185
|
budgetMib: z.ZodInt;
|
|
3758
5186
|
usedMib: z.ZodInt;
|
|
3759
5187
|
requestedMib: z.ZodInt;
|
|
5188
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5189
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5190
|
+
name: z.ZodString;
|
|
5191
|
+
ramMib: z.ZodInt;
|
|
5192
|
+
leased: z.ZodBoolean;
|
|
5193
|
+
busy: z.ZodBoolean;
|
|
5194
|
+
}, z.core.$strip>>>>;
|
|
5195
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3760
5196
|
}, z.core.$strip>;
|
|
3761
5197
|
};
|
|
3762
5198
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3791,6 +5227,26 @@ declare const impContract: {
|
|
|
3791
5227
|
requestedBytes: z.ZodInt;
|
|
3792
5228
|
}, z.core.$strip>;
|
|
3793
5229
|
};
|
|
5230
|
+
LEASED: {
|
|
5231
|
+
readonly message: "The imp is leased";
|
|
5232
|
+
readonly status: 409;
|
|
5233
|
+
readonly data: z.ZodObject<{
|
|
5234
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5235
|
+
name: z.ZodString;
|
|
5236
|
+
owner: z.ZodObject<{
|
|
5237
|
+
principal: z.ZodString;
|
|
5238
|
+
display: z.ZodString;
|
|
5239
|
+
label: z.ZodString;
|
|
5240
|
+
}, z.core.$strip>;
|
|
5241
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5242
|
+
}, z.core.$strip>>>;
|
|
5243
|
+
otherCount: z.ZodInt;
|
|
5244
|
+
}, z.core.$strip>;
|
|
5245
|
+
};
|
|
5246
|
+
LEASE_NOT_HELD: {
|
|
5247
|
+
readonly message: "The caller holds no such lease";
|
|
5248
|
+
readonly status: 409;
|
|
5249
|
+
};
|
|
3794
5250
|
AGENT_OUTDATED: {
|
|
3795
5251
|
readonly message: "The imp's agent is too old for this";
|
|
3796
5252
|
readonly status: 409;
|
|
@@ -3865,6 +5321,14 @@ declare const impContract: {
|
|
|
3865
5321
|
budgetMib: z.ZodInt;
|
|
3866
5322
|
usedMib: z.ZodInt;
|
|
3867
5323
|
requestedMib: z.ZodInt;
|
|
5324
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5325
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5326
|
+
name: z.ZodString;
|
|
5327
|
+
ramMib: z.ZodInt;
|
|
5328
|
+
leased: z.ZodBoolean;
|
|
5329
|
+
busy: z.ZodBoolean;
|
|
5330
|
+
}, z.core.$strip>>>>;
|
|
5331
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3868
5332
|
}, z.core.$strip>;
|
|
3869
5333
|
};
|
|
3870
5334
|
SERVICE_UNAVAILABLE: {
|
|
@@ -3899,6 +5363,26 @@ declare const impContract: {
|
|
|
3899
5363
|
requestedBytes: z.ZodInt;
|
|
3900
5364
|
}, z.core.$strip>;
|
|
3901
5365
|
};
|
|
5366
|
+
LEASED: {
|
|
5367
|
+
readonly message: "The imp is leased";
|
|
5368
|
+
readonly status: 409;
|
|
5369
|
+
readonly data: z.ZodObject<{
|
|
5370
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5371
|
+
name: z.ZodString;
|
|
5372
|
+
owner: z.ZodObject<{
|
|
5373
|
+
principal: z.ZodString;
|
|
5374
|
+
display: z.ZodString;
|
|
5375
|
+
label: z.ZodString;
|
|
5376
|
+
}, z.core.$strip>;
|
|
5377
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5378
|
+
}, z.core.$strip>>>;
|
|
5379
|
+
otherCount: z.ZodInt;
|
|
5380
|
+
}, z.core.$strip>;
|
|
5381
|
+
};
|
|
5382
|
+
LEASE_NOT_HELD: {
|
|
5383
|
+
readonly message: "The caller holds no such lease";
|
|
5384
|
+
readonly status: 409;
|
|
5385
|
+
};
|
|
3902
5386
|
AGENT_OUTDATED: {
|
|
3903
5387
|
readonly message: "The imp's agent is too old for this";
|
|
3904
5388
|
readonly status: 409;
|
|
@@ -3971,6 +5455,14 @@ declare const impContract: {
|
|
|
3971
5455
|
budgetMib: z.ZodInt;
|
|
3972
5456
|
usedMib: z.ZodInt;
|
|
3973
5457
|
requestedMib: z.ZodInt;
|
|
5458
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5459
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5460
|
+
name: z.ZodString;
|
|
5461
|
+
ramMib: z.ZodInt;
|
|
5462
|
+
leased: z.ZodBoolean;
|
|
5463
|
+
busy: z.ZodBoolean;
|
|
5464
|
+
}, z.core.$strip>>>>;
|
|
5465
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
3974
5466
|
}, z.core.$strip>;
|
|
3975
5467
|
};
|
|
3976
5468
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4005,6 +5497,26 @@ declare const impContract: {
|
|
|
4005
5497
|
requestedBytes: z.ZodInt;
|
|
4006
5498
|
}, z.core.$strip>;
|
|
4007
5499
|
};
|
|
5500
|
+
LEASED: {
|
|
5501
|
+
readonly message: "The imp is leased";
|
|
5502
|
+
readonly status: 409;
|
|
5503
|
+
readonly data: z.ZodObject<{
|
|
5504
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5505
|
+
name: z.ZodString;
|
|
5506
|
+
owner: z.ZodObject<{
|
|
5507
|
+
principal: z.ZodString;
|
|
5508
|
+
display: z.ZodString;
|
|
5509
|
+
label: z.ZodString;
|
|
5510
|
+
}, z.core.$strip>;
|
|
5511
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5512
|
+
}, z.core.$strip>>>;
|
|
5513
|
+
otherCount: z.ZodInt;
|
|
5514
|
+
}, z.core.$strip>;
|
|
5515
|
+
};
|
|
5516
|
+
LEASE_NOT_HELD: {
|
|
5517
|
+
readonly message: "The caller holds no such lease";
|
|
5518
|
+
readonly status: 409;
|
|
5519
|
+
};
|
|
4008
5520
|
AGENT_OUTDATED: {
|
|
4009
5521
|
readonly message: "The imp's agent is too old for this";
|
|
4010
5522
|
readonly status: 409;
|
|
@@ -4064,6 +5576,14 @@ declare const impContract: {
|
|
|
4064
5576
|
budgetMib: z.ZodInt;
|
|
4065
5577
|
usedMib: z.ZodInt;
|
|
4066
5578
|
requestedMib: z.ZodInt;
|
|
5579
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5580
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5581
|
+
name: z.ZodString;
|
|
5582
|
+
ramMib: z.ZodInt;
|
|
5583
|
+
leased: z.ZodBoolean;
|
|
5584
|
+
busy: z.ZodBoolean;
|
|
5585
|
+
}, z.core.$strip>>>>;
|
|
5586
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4067
5587
|
}, z.core.$strip>;
|
|
4068
5588
|
};
|
|
4069
5589
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4098,6 +5618,26 @@ declare const impContract: {
|
|
|
4098
5618
|
requestedBytes: z.ZodInt;
|
|
4099
5619
|
}, z.core.$strip>;
|
|
4100
5620
|
};
|
|
5621
|
+
LEASED: {
|
|
5622
|
+
readonly message: "The imp is leased";
|
|
5623
|
+
readonly status: 409;
|
|
5624
|
+
readonly data: z.ZodObject<{
|
|
5625
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5626
|
+
name: z.ZodString;
|
|
5627
|
+
owner: z.ZodObject<{
|
|
5628
|
+
principal: z.ZodString;
|
|
5629
|
+
display: z.ZodString;
|
|
5630
|
+
label: z.ZodString;
|
|
5631
|
+
}, z.core.$strip>;
|
|
5632
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5633
|
+
}, z.core.$strip>>>;
|
|
5634
|
+
otherCount: z.ZodInt;
|
|
5635
|
+
}, z.core.$strip>;
|
|
5636
|
+
};
|
|
5637
|
+
LEASE_NOT_HELD: {
|
|
5638
|
+
readonly message: "The caller holds no such lease";
|
|
5639
|
+
readonly status: 409;
|
|
5640
|
+
};
|
|
4101
5641
|
AGENT_OUTDATED: {
|
|
4102
5642
|
readonly message: "The imp's agent is too old for this";
|
|
4103
5643
|
readonly status: 409;
|
|
@@ -4162,6 +5702,14 @@ declare const impContract: {
|
|
|
4162
5702
|
budgetMib: z.ZodInt;
|
|
4163
5703
|
usedMib: z.ZodInt;
|
|
4164
5704
|
requestedMib: z.ZodInt;
|
|
5705
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5706
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5707
|
+
name: z.ZodString;
|
|
5708
|
+
ramMib: z.ZodInt;
|
|
5709
|
+
leased: z.ZodBoolean;
|
|
5710
|
+
busy: z.ZodBoolean;
|
|
5711
|
+
}, z.core.$strip>>>>;
|
|
5712
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4165
5713
|
}, z.core.$strip>;
|
|
4166
5714
|
};
|
|
4167
5715
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4196,6 +5744,26 @@ declare const impContract: {
|
|
|
4196
5744
|
requestedBytes: z.ZodInt;
|
|
4197
5745
|
}, z.core.$strip>;
|
|
4198
5746
|
};
|
|
5747
|
+
LEASED: {
|
|
5748
|
+
readonly message: "The imp is leased";
|
|
5749
|
+
readonly status: 409;
|
|
5750
|
+
readonly data: z.ZodObject<{
|
|
5751
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5752
|
+
name: z.ZodString;
|
|
5753
|
+
owner: z.ZodObject<{
|
|
5754
|
+
principal: z.ZodString;
|
|
5755
|
+
display: z.ZodString;
|
|
5756
|
+
label: z.ZodString;
|
|
5757
|
+
}, z.core.$strip>;
|
|
5758
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5759
|
+
}, z.core.$strip>>>;
|
|
5760
|
+
otherCount: z.ZodInt;
|
|
5761
|
+
}, z.core.$strip>;
|
|
5762
|
+
};
|
|
5763
|
+
LEASE_NOT_HELD: {
|
|
5764
|
+
readonly message: "The caller holds no such lease";
|
|
5765
|
+
readonly status: 409;
|
|
5766
|
+
};
|
|
4199
5767
|
AGENT_OUTDATED: {
|
|
4200
5768
|
readonly message: "The imp's agent is too old for this";
|
|
4201
5769
|
readonly status: 409;
|
|
@@ -4273,6 +5841,14 @@ declare const impContract: {
|
|
|
4273
5841
|
budgetMib: z.ZodInt;
|
|
4274
5842
|
usedMib: z.ZodInt;
|
|
4275
5843
|
requestedMib: z.ZodInt;
|
|
5844
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5845
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5846
|
+
name: z.ZodString;
|
|
5847
|
+
ramMib: z.ZodInt;
|
|
5848
|
+
leased: z.ZodBoolean;
|
|
5849
|
+
busy: z.ZodBoolean;
|
|
5850
|
+
}, z.core.$strip>>>>;
|
|
5851
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4276
5852
|
}, z.core.$strip>;
|
|
4277
5853
|
};
|
|
4278
5854
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4307,6 +5883,26 @@ declare const impContract: {
|
|
|
4307
5883
|
requestedBytes: z.ZodInt;
|
|
4308
5884
|
}, z.core.$strip>;
|
|
4309
5885
|
};
|
|
5886
|
+
LEASED: {
|
|
5887
|
+
readonly message: "The imp is leased";
|
|
5888
|
+
readonly status: 409;
|
|
5889
|
+
readonly data: z.ZodObject<{
|
|
5890
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5891
|
+
name: z.ZodString;
|
|
5892
|
+
owner: z.ZodObject<{
|
|
5893
|
+
principal: z.ZodString;
|
|
5894
|
+
display: z.ZodString;
|
|
5895
|
+
label: z.ZodString;
|
|
5896
|
+
}, z.core.$strip>;
|
|
5897
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
5898
|
+
}, z.core.$strip>>>;
|
|
5899
|
+
otherCount: z.ZodInt;
|
|
5900
|
+
}, z.core.$strip>;
|
|
5901
|
+
};
|
|
5902
|
+
LEASE_NOT_HELD: {
|
|
5903
|
+
readonly message: "The caller holds no such lease";
|
|
5904
|
+
readonly status: 409;
|
|
5905
|
+
};
|
|
4310
5906
|
AGENT_OUTDATED: {
|
|
4311
5907
|
readonly message: "The imp's agent is too old for this";
|
|
4312
5908
|
readonly status: 409;
|
|
@@ -4367,6 +5963,14 @@ declare const impContract: {
|
|
|
4367
5963
|
budgetMib: z.ZodInt;
|
|
4368
5964
|
usedMib: z.ZodInt;
|
|
4369
5965
|
requestedMib: z.ZodInt;
|
|
5966
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
5967
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
5968
|
+
name: z.ZodString;
|
|
5969
|
+
ramMib: z.ZodInt;
|
|
5970
|
+
leased: z.ZodBoolean;
|
|
5971
|
+
busy: z.ZodBoolean;
|
|
5972
|
+
}, z.core.$strip>>>>;
|
|
5973
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4370
5974
|
}, z.core.$strip>;
|
|
4371
5975
|
};
|
|
4372
5976
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4401,6 +6005,26 @@ declare const impContract: {
|
|
|
4401
6005
|
requestedBytes: z.ZodInt;
|
|
4402
6006
|
}, z.core.$strip>;
|
|
4403
6007
|
};
|
|
6008
|
+
LEASED: {
|
|
6009
|
+
readonly message: "The imp is leased";
|
|
6010
|
+
readonly status: 409;
|
|
6011
|
+
readonly data: z.ZodObject<{
|
|
6012
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6013
|
+
name: z.ZodString;
|
|
6014
|
+
owner: z.ZodObject<{
|
|
6015
|
+
principal: z.ZodString;
|
|
6016
|
+
display: z.ZodString;
|
|
6017
|
+
label: z.ZodString;
|
|
6018
|
+
}, z.core.$strip>;
|
|
6019
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6020
|
+
}, z.core.$strip>>>;
|
|
6021
|
+
otherCount: z.ZodInt;
|
|
6022
|
+
}, z.core.$strip>;
|
|
6023
|
+
};
|
|
6024
|
+
LEASE_NOT_HELD: {
|
|
6025
|
+
readonly message: "The caller holds no such lease";
|
|
6026
|
+
readonly status: 409;
|
|
6027
|
+
};
|
|
4404
6028
|
AGENT_OUTDATED: {
|
|
4405
6029
|
readonly message: "The imp's agent is too old for this";
|
|
4406
6030
|
readonly status: 409;
|
|
@@ -4494,6 +6118,14 @@ declare const impContract: {
|
|
|
4494
6118
|
budgetMib: z.ZodInt;
|
|
4495
6119
|
usedMib: z.ZodInt;
|
|
4496
6120
|
requestedMib: z.ZodInt;
|
|
6121
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6122
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6123
|
+
name: z.ZodString;
|
|
6124
|
+
ramMib: z.ZodInt;
|
|
6125
|
+
leased: z.ZodBoolean;
|
|
6126
|
+
busy: z.ZodBoolean;
|
|
6127
|
+
}, z.core.$strip>>>>;
|
|
6128
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4497
6129
|
}, z.core.$strip>;
|
|
4498
6130
|
};
|
|
4499
6131
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4528,6 +6160,26 @@ declare const impContract: {
|
|
|
4528
6160
|
requestedBytes: z.ZodInt;
|
|
4529
6161
|
}, z.core.$strip>;
|
|
4530
6162
|
};
|
|
6163
|
+
LEASED: {
|
|
6164
|
+
readonly message: "The imp is leased";
|
|
6165
|
+
readonly status: 409;
|
|
6166
|
+
readonly data: z.ZodObject<{
|
|
6167
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6168
|
+
name: z.ZodString;
|
|
6169
|
+
owner: z.ZodObject<{
|
|
6170
|
+
principal: z.ZodString;
|
|
6171
|
+
display: z.ZodString;
|
|
6172
|
+
label: z.ZodString;
|
|
6173
|
+
}, z.core.$strip>;
|
|
6174
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6175
|
+
}, z.core.$strip>>>;
|
|
6176
|
+
otherCount: z.ZodInt;
|
|
6177
|
+
}, z.core.$strip>;
|
|
6178
|
+
};
|
|
6179
|
+
LEASE_NOT_HELD: {
|
|
6180
|
+
readonly message: "The caller holds no such lease";
|
|
6181
|
+
readonly status: 409;
|
|
6182
|
+
};
|
|
4531
6183
|
AGENT_OUTDATED: {
|
|
4532
6184
|
readonly message: "The imp's agent is too old for this";
|
|
4533
6185
|
readonly status: 409;
|
|
@@ -4600,6 +6252,14 @@ declare const impContract: {
|
|
|
4600
6252
|
budgetMib: z.ZodInt;
|
|
4601
6253
|
usedMib: z.ZodInt;
|
|
4602
6254
|
requestedMib: z.ZodInt;
|
|
6255
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6256
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6257
|
+
name: z.ZodString;
|
|
6258
|
+
ramMib: z.ZodInt;
|
|
6259
|
+
leased: z.ZodBoolean;
|
|
6260
|
+
busy: z.ZodBoolean;
|
|
6261
|
+
}, z.core.$strip>>>>;
|
|
6262
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4603
6263
|
}, z.core.$strip>;
|
|
4604
6264
|
};
|
|
4605
6265
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4634,6 +6294,26 @@ declare const impContract: {
|
|
|
4634
6294
|
requestedBytes: z.ZodInt;
|
|
4635
6295
|
}, z.core.$strip>;
|
|
4636
6296
|
};
|
|
6297
|
+
LEASED: {
|
|
6298
|
+
readonly message: "The imp is leased";
|
|
6299
|
+
readonly status: 409;
|
|
6300
|
+
readonly data: z.ZodObject<{
|
|
6301
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6302
|
+
name: z.ZodString;
|
|
6303
|
+
owner: z.ZodObject<{
|
|
6304
|
+
principal: z.ZodString;
|
|
6305
|
+
display: z.ZodString;
|
|
6306
|
+
label: z.ZodString;
|
|
6307
|
+
}, z.core.$strip>;
|
|
6308
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6309
|
+
}, z.core.$strip>>>;
|
|
6310
|
+
otherCount: z.ZodInt;
|
|
6311
|
+
}, z.core.$strip>;
|
|
6312
|
+
};
|
|
6313
|
+
LEASE_NOT_HELD: {
|
|
6314
|
+
readonly message: "The caller holds no such lease";
|
|
6315
|
+
readonly status: 409;
|
|
6316
|
+
};
|
|
4637
6317
|
AGENT_OUTDATED: {
|
|
4638
6318
|
readonly message: "The imp's agent is too old for this";
|
|
4639
6319
|
readonly status: 409;
|
|
@@ -4694,6 +6374,14 @@ declare const impContract: {
|
|
|
4694
6374
|
budgetMib: z.ZodInt;
|
|
4695
6375
|
usedMib: z.ZodInt;
|
|
4696
6376
|
requestedMib: z.ZodInt;
|
|
6377
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6378
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6379
|
+
name: z.ZodString;
|
|
6380
|
+
ramMib: z.ZodInt;
|
|
6381
|
+
leased: z.ZodBoolean;
|
|
6382
|
+
busy: z.ZodBoolean;
|
|
6383
|
+
}, z.core.$strip>>>>;
|
|
6384
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4697
6385
|
}, z.core.$strip>;
|
|
4698
6386
|
};
|
|
4699
6387
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4728,6 +6416,26 @@ declare const impContract: {
|
|
|
4728
6416
|
requestedBytes: z.ZodInt;
|
|
4729
6417
|
}, z.core.$strip>;
|
|
4730
6418
|
};
|
|
6419
|
+
LEASED: {
|
|
6420
|
+
readonly message: "The imp is leased";
|
|
6421
|
+
readonly status: 409;
|
|
6422
|
+
readonly data: z.ZodObject<{
|
|
6423
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6424
|
+
name: z.ZodString;
|
|
6425
|
+
owner: z.ZodObject<{
|
|
6426
|
+
principal: z.ZodString;
|
|
6427
|
+
display: z.ZodString;
|
|
6428
|
+
label: z.ZodString;
|
|
6429
|
+
}, z.core.$strip>;
|
|
6430
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6431
|
+
}, z.core.$strip>>>;
|
|
6432
|
+
otherCount: z.ZodInt;
|
|
6433
|
+
}, z.core.$strip>;
|
|
6434
|
+
};
|
|
6435
|
+
LEASE_NOT_HELD: {
|
|
6436
|
+
readonly message: "The caller holds no such lease";
|
|
6437
|
+
readonly status: 409;
|
|
6438
|
+
};
|
|
4731
6439
|
AGENT_OUTDATED: {
|
|
4732
6440
|
readonly message: "The imp's agent is too old for this";
|
|
4733
6441
|
readonly status: 409;
|
|
@@ -4788,6 +6496,14 @@ declare const impContract: {
|
|
|
4788
6496
|
budgetMib: z.ZodInt;
|
|
4789
6497
|
usedMib: z.ZodInt;
|
|
4790
6498
|
requestedMib: z.ZodInt;
|
|
6499
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6500
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6501
|
+
name: z.ZodString;
|
|
6502
|
+
ramMib: z.ZodInt;
|
|
6503
|
+
leased: z.ZodBoolean;
|
|
6504
|
+
busy: z.ZodBoolean;
|
|
6505
|
+
}, z.core.$strip>>>>;
|
|
6506
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4791
6507
|
}, z.core.$strip>;
|
|
4792
6508
|
};
|
|
4793
6509
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4822,6 +6538,26 @@ declare const impContract: {
|
|
|
4822
6538
|
requestedBytes: z.ZodInt;
|
|
4823
6539
|
}, z.core.$strip>;
|
|
4824
6540
|
};
|
|
6541
|
+
LEASED: {
|
|
6542
|
+
readonly message: "The imp is leased";
|
|
6543
|
+
readonly status: 409;
|
|
6544
|
+
readonly data: z.ZodObject<{
|
|
6545
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6546
|
+
name: z.ZodString;
|
|
6547
|
+
owner: z.ZodObject<{
|
|
6548
|
+
principal: z.ZodString;
|
|
6549
|
+
display: z.ZodString;
|
|
6550
|
+
label: z.ZodString;
|
|
6551
|
+
}, z.core.$strip>;
|
|
6552
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6553
|
+
}, z.core.$strip>>>;
|
|
6554
|
+
otherCount: z.ZodInt;
|
|
6555
|
+
}, z.core.$strip>;
|
|
6556
|
+
};
|
|
6557
|
+
LEASE_NOT_HELD: {
|
|
6558
|
+
readonly message: "The caller holds no such lease";
|
|
6559
|
+
readonly status: 409;
|
|
6560
|
+
};
|
|
4825
6561
|
AGENT_OUTDATED: {
|
|
4826
6562
|
readonly message: "The imp's agent is too old for this";
|
|
4827
6563
|
readonly status: 409;
|
|
@@ -4906,6 +6642,14 @@ declare const impContract: {
|
|
|
4906
6642
|
budgetMib: z.ZodInt;
|
|
4907
6643
|
usedMib: z.ZodInt;
|
|
4908
6644
|
requestedMib: z.ZodInt;
|
|
6645
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6646
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6647
|
+
name: z.ZodString;
|
|
6648
|
+
ramMib: z.ZodInt;
|
|
6649
|
+
leased: z.ZodBoolean;
|
|
6650
|
+
busy: z.ZodBoolean;
|
|
6651
|
+
}, z.core.$strip>>>>;
|
|
6652
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
4909
6653
|
}, z.core.$strip>;
|
|
4910
6654
|
};
|
|
4911
6655
|
SERVICE_UNAVAILABLE: {
|
|
@@ -4940,6 +6684,26 @@ declare const impContract: {
|
|
|
4940
6684
|
requestedBytes: z.ZodInt;
|
|
4941
6685
|
}, z.core.$strip>;
|
|
4942
6686
|
};
|
|
6687
|
+
LEASED: {
|
|
6688
|
+
readonly message: "The imp is leased";
|
|
6689
|
+
readonly status: 409;
|
|
6690
|
+
readonly data: z.ZodObject<{
|
|
6691
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6692
|
+
name: z.ZodString;
|
|
6693
|
+
owner: z.ZodObject<{
|
|
6694
|
+
principal: z.ZodString;
|
|
6695
|
+
display: z.ZodString;
|
|
6696
|
+
label: z.ZodString;
|
|
6697
|
+
}, z.core.$strip>;
|
|
6698
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6699
|
+
}, z.core.$strip>>>;
|
|
6700
|
+
otherCount: z.ZodInt;
|
|
6701
|
+
}, z.core.$strip>;
|
|
6702
|
+
};
|
|
6703
|
+
LEASE_NOT_HELD: {
|
|
6704
|
+
readonly message: "The caller holds no such lease";
|
|
6705
|
+
readonly status: 409;
|
|
6706
|
+
};
|
|
4943
6707
|
AGENT_OUTDATED: {
|
|
4944
6708
|
readonly message: "The imp's agent is too old for this";
|
|
4945
6709
|
readonly status: 409;
|
|
@@ -5039,6 +6803,14 @@ declare const impContract: {
|
|
|
5039
6803
|
budgetMib: z.ZodInt;
|
|
5040
6804
|
usedMib: z.ZodInt;
|
|
5041
6805
|
requestedMib: z.ZodInt;
|
|
6806
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6807
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6808
|
+
name: z.ZodString;
|
|
6809
|
+
ramMib: z.ZodInt;
|
|
6810
|
+
leased: z.ZodBoolean;
|
|
6811
|
+
busy: z.ZodBoolean;
|
|
6812
|
+
}, z.core.$strip>>>>;
|
|
6813
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5042
6814
|
}, z.core.$strip>;
|
|
5043
6815
|
};
|
|
5044
6816
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5073,6 +6845,26 @@ declare const impContract: {
|
|
|
5073
6845
|
requestedBytes: z.ZodInt;
|
|
5074
6846
|
}, z.core.$strip>;
|
|
5075
6847
|
};
|
|
6848
|
+
LEASED: {
|
|
6849
|
+
readonly message: "The imp is leased";
|
|
6850
|
+
readonly status: 409;
|
|
6851
|
+
readonly data: z.ZodObject<{
|
|
6852
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6853
|
+
name: z.ZodString;
|
|
6854
|
+
owner: z.ZodObject<{
|
|
6855
|
+
principal: z.ZodString;
|
|
6856
|
+
display: z.ZodString;
|
|
6857
|
+
label: z.ZodString;
|
|
6858
|
+
}, z.core.$strip>;
|
|
6859
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6860
|
+
}, z.core.$strip>>>;
|
|
6861
|
+
otherCount: z.ZodInt;
|
|
6862
|
+
}, z.core.$strip>;
|
|
6863
|
+
};
|
|
6864
|
+
LEASE_NOT_HELD: {
|
|
6865
|
+
readonly message: "The caller holds no such lease";
|
|
6866
|
+
readonly status: 409;
|
|
6867
|
+
};
|
|
5076
6868
|
AGENT_OUTDATED: {
|
|
5077
6869
|
readonly message: "The imp's agent is too old for this";
|
|
5078
6870
|
readonly status: 409;
|
|
@@ -5150,6 +6942,14 @@ declare const impContract: {
|
|
|
5150
6942
|
budgetMib: z.ZodInt;
|
|
5151
6943
|
usedMib: z.ZodInt;
|
|
5152
6944
|
requestedMib: z.ZodInt;
|
|
6945
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
6946
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6947
|
+
name: z.ZodString;
|
|
6948
|
+
ramMib: z.ZodInt;
|
|
6949
|
+
leased: z.ZodBoolean;
|
|
6950
|
+
busy: z.ZodBoolean;
|
|
6951
|
+
}, z.core.$strip>>>>;
|
|
6952
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5153
6953
|
}, z.core.$strip>;
|
|
5154
6954
|
};
|
|
5155
6955
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5184,6 +6984,26 @@ declare const impContract: {
|
|
|
5184
6984
|
requestedBytes: z.ZodInt;
|
|
5185
6985
|
}, z.core.$strip>;
|
|
5186
6986
|
};
|
|
6987
|
+
LEASED: {
|
|
6988
|
+
readonly message: "The imp is leased";
|
|
6989
|
+
readonly status: 409;
|
|
6990
|
+
readonly data: z.ZodObject<{
|
|
6991
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
6992
|
+
name: z.ZodString;
|
|
6993
|
+
owner: z.ZodObject<{
|
|
6994
|
+
principal: z.ZodString;
|
|
6995
|
+
display: z.ZodString;
|
|
6996
|
+
label: z.ZodString;
|
|
6997
|
+
}, z.core.$strip>;
|
|
6998
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
6999
|
+
}, z.core.$strip>>>;
|
|
7000
|
+
otherCount: z.ZodInt;
|
|
7001
|
+
}, z.core.$strip>;
|
|
7002
|
+
};
|
|
7003
|
+
LEASE_NOT_HELD: {
|
|
7004
|
+
readonly message: "The caller holds no such lease";
|
|
7005
|
+
readonly status: 409;
|
|
7006
|
+
};
|
|
5187
7007
|
AGENT_OUTDATED: {
|
|
5188
7008
|
readonly message: "The imp's agent is too old for this";
|
|
5189
7009
|
readonly status: 409;
|
|
@@ -5243,6 +7063,14 @@ declare const impContract: {
|
|
|
5243
7063
|
budgetMib: z.ZodInt;
|
|
5244
7064
|
usedMib: z.ZodInt;
|
|
5245
7065
|
requestedMib: z.ZodInt;
|
|
7066
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7067
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7068
|
+
name: z.ZodString;
|
|
7069
|
+
ramMib: z.ZodInt;
|
|
7070
|
+
leased: z.ZodBoolean;
|
|
7071
|
+
busy: z.ZodBoolean;
|
|
7072
|
+
}, z.core.$strip>>>>;
|
|
7073
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5246
7074
|
}, z.core.$strip>;
|
|
5247
7075
|
};
|
|
5248
7076
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5277,6 +7105,26 @@ declare const impContract: {
|
|
|
5277
7105
|
requestedBytes: z.ZodInt;
|
|
5278
7106
|
}, z.core.$strip>;
|
|
5279
7107
|
};
|
|
7108
|
+
LEASED: {
|
|
7109
|
+
readonly message: "The imp is leased";
|
|
7110
|
+
readonly status: 409;
|
|
7111
|
+
readonly data: z.ZodObject<{
|
|
7112
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7113
|
+
name: z.ZodString;
|
|
7114
|
+
owner: z.ZodObject<{
|
|
7115
|
+
principal: z.ZodString;
|
|
7116
|
+
display: z.ZodString;
|
|
7117
|
+
label: z.ZodString;
|
|
7118
|
+
}, z.core.$strip>;
|
|
7119
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7120
|
+
}, z.core.$strip>>>;
|
|
7121
|
+
otherCount: z.ZodInt;
|
|
7122
|
+
}, z.core.$strip>;
|
|
7123
|
+
};
|
|
7124
|
+
LEASE_NOT_HELD: {
|
|
7125
|
+
readonly message: "The caller holds no such lease";
|
|
7126
|
+
readonly status: 409;
|
|
7127
|
+
};
|
|
5280
7128
|
AGENT_OUTDATED: {
|
|
5281
7129
|
readonly message: "The imp's agent is too old for this";
|
|
5282
7130
|
readonly status: 409;
|
|
@@ -5340,6 +7188,14 @@ declare const impContract: {
|
|
|
5340
7188
|
budgetMib: z.ZodInt;
|
|
5341
7189
|
usedMib: z.ZodInt;
|
|
5342
7190
|
requestedMib: z.ZodInt;
|
|
7191
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7192
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7193
|
+
name: z.ZodString;
|
|
7194
|
+
ramMib: z.ZodInt;
|
|
7195
|
+
leased: z.ZodBoolean;
|
|
7196
|
+
busy: z.ZodBoolean;
|
|
7197
|
+
}, z.core.$strip>>>>;
|
|
7198
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5343
7199
|
}, z.core.$strip>;
|
|
5344
7200
|
};
|
|
5345
7201
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5374,6 +7230,26 @@ declare const impContract: {
|
|
|
5374
7230
|
requestedBytes: z.ZodInt;
|
|
5375
7231
|
}, z.core.$strip>;
|
|
5376
7232
|
};
|
|
7233
|
+
LEASED: {
|
|
7234
|
+
readonly message: "The imp is leased";
|
|
7235
|
+
readonly status: 409;
|
|
7236
|
+
readonly data: z.ZodObject<{
|
|
7237
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7238
|
+
name: z.ZodString;
|
|
7239
|
+
owner: z.ZodObject<{
|
|
7240
|
+
principal: z.ZodString;
|
|
7241
|
+
display: z.ZodString;
|
|
7242
|
+
label: z.ZodString;
|
|
7243
|
+
}, z.core.$strip>;
|
|
7244
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7245
|
+
}, z.core.$strip>>>;
|
|
7246
|
+
otherCount: z.ZodInt;
|
|
7247
|
+
}, z.core.$strip>;
|
|
7248
|
+
};
|
|
7249
|
+
LEASE_NOT_HELD: {
|
|
7250
|
+
readonly message: "The caller holds no such lease";
|
|
7251
|
+
readonly status: 409;
|
|
7252
|
+
};
|
|
5377
7253
|
AGENT_OUTDATED: {
|
|
5378
7254
|
readonly message: "The imp's agent is too old for this";
|
|
5379
7255
|
readonly status: 409;
|
|
@@ -5437,6 +7313,14 @@ declare const impContract: {
|
|
|
5437
7313
|
budgetMib: z.ZodInt;
|
|
5438
7314
|
usedMib: z.ZodInt;
|
|
5439
7315
|
requestedMib: z.ZodInt;
|
|
7316
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7317
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7318
|
+
name: z.ZodString;
|
|
7319
|
+
ramMib: z.ZodInt;
|
|
7320
|
+
leased: z.ZodBoolean;
|
|
7321
|
+
busy: z.ZodBoolean;
|
|
7322
|
+
}, z.core.$strip>>>>;
|
|
7323
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5440
7324
|
}, z.core.$strip>;
|
|
5441
7325
|
};
|
|
5442
7326
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5471,6 +7355,26 @@ declare const impContract: {
|
|
|
5471
7355
|
requestedBytes: z.ZodInt;
|
|
5472
7356
|
}, z.core.$strip>;
|
|
5473
7357
|
};
|
|
7358
|
+
LEASED: {
|
|
7359
|
+
readonly message: "The imp is leased";
|
|
7360
|
+
readonly status: 409;
|
|
7361
|
+
readonly data: z.ZodObject<{
|
|
7362
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7363
|
+
name: z.ZodString;
|
|
7364
|
+
owner: z.ZodObject<{
|
|
7365
|
+
principal: z.ZodString;
|
|
7366
|
+
display: z.ZodString;
|
|
7367
|
+
label: z.ZodString;
|
|
7368
|
+
}, z.core.$strip>;
|
|
7369
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7370
|
+
}, z.core.$strip>>>;
|
|
7371
|
+
otherCount: z.ZodInt;
|
|
7372
|
+
}, z.core.$strip>;
|
|
7373
|
+
};
|
|
7374
|
+
LEASE_NOT_HELD: {
|
|
7375
|
+
readonly message: "The caller holds no such lease";
|
|
7376
|
+
readonly status: 409;
|
|
7377
|
+
};
|
|
5474
7378
|
AGENT_OUTDATED: {
|
|
5475
7379
|
readonly message: "The imp's agent is too old for this";
|
|
5476
7380
|
readonly status: 409;
|
|
@@ -5530,6 +7434,14 @@ declare const impContract: {
|
|
|
5530
7434
|
budgetMib: z.ZodInt;
|
|
5531
7435
|
usedMib: z.ZodInt;
|
|
5532
7436
|
requestedMib: z.ZodInt;
|
|
7437
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7438
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7439
|
+
name: z.ZodString;
|
|
7440
|
+
ramMib: z.ZodInt;
|
|
7441
|
+
leased: z.ZodBoolean;
|
|
7442
|
+
busy: z.ZodBoolean;
|
|
7443
|
+
}, z.core.$strip>>>>;
|
|
7444
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5533
7445
|
}, z.core.$strip>;
|
|
5534
7446
|
};
|
|
5535
7447
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5564,6 +7476,26 @@ declare const impContract: {
|
|
|
5564
7476
|
requestedBytes: z.ZodInt;
|
|
5565
7477
|
}, z.core.$strip>;
|
|
5566
7478
|
};
|
|
7479
|
+
LEASED: {
|
|
7480
|
+
readonly message: "The imp is leased";
|
|
7481
|
+
readonly status: 409;
|
|
7482
|
+
readonly data: z.ZodObject<{
|
|
7483
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7484
|
+
name: z.ZodString;
|
|
7485
|
+
owner: z.ZodObject<{
|
|
7486
|
+
principal: z.ZodString;
|
|
7487
|
+
display: z.ZodString;
|
|
7488
|
+
label: z.ZodString;
|
|
7489
|
+
}, z.core.$strip>;
|
|
7490
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7491
|
+
}, z.core.$strip>>>;
|
|
7492
|
+
otherCount: z.ZodInt;
|
|
7493
|
+
}, z.core.$strip>;
|
|
7494
|
+
};
|
|
7495
|
+
LEASE_NOT_HELD: {
|
|
7496
|
+
readonly message: "The caller holds no such lease";
|
|
7497
|
+
readonly status: 409;
|
|
7498
|
+
};
|
|
5567
7499
|
AGENT_OUTDATED: {
|
|
5568
7500
|
readonly message: "The imp's agent is too old for this";
|
|
5569
7501
|
readonly status: 409;
|
|
@@ -5629,6 +7561,14 @@ declare const impContract: {
|
|
|
5629
7561
|
budgetMib: z.ZodInt;
|
|
5630
7562
|
usedMib: z.ZodInt;
|
|
5631
7563
|
requestedMib: z.ZodInt;
|
|
7564
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7565
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7566
|
+
name: z.ZodString;
|
|
7567
|
+
ramMib: z.ZodInt;
|
|
7568
|
+
leased: z.ZodBoolean;
|
|
7569
|
+
busy: z.ZodBoolean;
|
|
7570
|
+
}, z.core.$strip>>>>;
|
|
7571
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5632
7572
|
}, z.core.$strip>;
|
|
5633
7573
|
};
|
|
5634
7574
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5663,6 +7603,26 @@ declare const impContract: {
|
|
|
5663
7603
|
requestedBytes: z.ZodInt;
|
|
5664
7604
|
}, z.core.$strip>;
|
|
5665
7605
|
};
|
|
7606
|
+
LEASED: {
|
|
7607
|
+
readonly message: "The imp is leased";
|
|
7608
|
+
readonly status: 409;
|
|
7609
|
+
readonly data: z.ZodObject<{
|
|
7610
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7611
|
+
name: z.ZodString;
|
|
7612
|
+
owner: z.ZodObject<{
|
|
7613
|
+
principal: z.ZodString;
|
|
7614
|
+
display: z.ZodString;
|
|
7615
|
+
label: z.ZodString;
|
|
7616
|
+
}, z.core.$strip>;
|
|
7617
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7618
|
+
}, z.core.$strip>>>;
|
|
7619
|
+
otherCount: z.ZodInt;
|
|
7620
|
+
}, z.core.$strip>;
|
|
7621
|
+
};
|
|
7622
|
+
LEASE_NOT_HELD: {
|
|
7623
|
+
readonly message: "The caller holds no such lease";
|
|
7624
|
+
readonly status: 409;
|
|
7625
|
+
};
|
|
5666
7626
|
AGENT_OUTDATED: {
|
|
5667
7627
|
readonly message: "The imp's agent is too old for this";
|
|
5668
7628
|
readonly status: 409;
|
|
@@ -5722,6 +7682,14 @@ declare const impContract: {
|
|
|
5722
7682
|
budgetMib: z.ZodInt;
|
|
5723
7683
|
usedMib: z.ZodInt;
|
|
5724
7684
|
requestedMib: z.ZodInt;
|
|
7685
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7686
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7687
|
+
name: z.ZodString;
|
|
7688
|
+
ramMib: z.ZodInt;
|
|
7689
|
+
leased: z.ZodBoolean;
|
|
7690
|
+
busy: z.ZodBoolean;
|
|
7691
|
+
}, z.core.$strip>>>>;
|
|
7692
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5725
7693
|
}, z.core.$strip>;
|
|
5726
7694
|
};
|
|
5727
7695
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5756,6 +7724,26 @@ declare const impContract: {
|
|
|
5756
7724
|
requestedBytes: z.ZodInt;
|
|
5757
7725
|
}, z.core.$strip>;
|
|
5758
7726
|
};
|
|
7727
|
+
LEASED: {
|
|
7728
|
+
readonly message: "The imp is leased";
|
|
7729
|
+
readonly status: 409;
|
|
7730
|
+
readonly data: z.ZodObject<{
|
|
7731
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7732
|
+
name: z.ZodString;
|
|
7733
|
+
owner: z.ZodObject<{
|
|
7734
|
+
principal: z.ZodString;
|
|
7735
|
+
display: z.ZodString;
|
|
7736
|
+
label: z.ZodString;
|
|
7737
|
+
}, z.core.$strip>;
|
|
7738
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7739
|
+
}, z.core.$strip>>>;
|
|
7740
|
+
otherCount: z.ZodInt;
|
|
7741
|
+
}, z.core.$strip>;
|
|
7742
|
+
};
|
|
7743
|
+
LEASE_NOT_HELD: {
|
|
7744
|
+
readonly message: "The caller holds no such lease";
|
|
7745
|
+
readonly status: 409;
|
|
7746
|
+
};
|
|
5759
7747
|
AGENT_OUTDATED: {
|
|
5760
7748
|
readonly message: "The imp's agent is too old for this";
|
|
5761
7749
|
readonly status: 409;
|
|
@@ -5820,6 +7808,14 @@ declare const impContract: {
|
|
|
5820
7808
|
budgetMib: z.ZodInt;
|
|
5821
7809
|
usedMib: z.ZodInt;
|
|
5822
7810
|
requestedMib: z.ZodInt;
|
|
7811
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7812
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7813
|
+
name: z.ZodString;
|
|
7814
|
+
ramMib: z.ZodInt;
|
|
7815
|
+
leased: z.ZodBoolean;
|
|
7816
|
+
busy: z.ZodBoolean;
|
|
7817
|
+
}, z.core.$strip>>>>;
|
|
7818
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5823
7819
|
}, z.core.$strip>;
|
|
5824
7820
|
};
|
|
5825
7821
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5854,6 +7850,26 @@ declare const impContract: {
|
|
|
5854
7850
|
requestedBytes: z.ZodInt;
|
|
5855
7851
|
}, z.core.$strip>;
|
|
5856
7852
|
};
|
|
7853
|
+
LEASED: {
|
|
7854
|
+
readonly message: "The imp is leased";
|
|
7855
|
+
readonly status: 409;
|
|
7856
|
+
readonly data: z.ZodObject<{
|
|
7857
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7858
|
+
name: z.ZodString;
|
|
7859
|
+
owner: z.ZodObject<{
|
|
7860
|
+
principal: z.ZodString;
|
|
7861
|
+
display: z.ZodString;
|
|
7862
|
+
label: z.ZodString;
|
|
7863
|
+
}, z.core.$strip>;
|
|
7864
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7865
|
+
}, z.core.$strip>>>;
|
|
7866
|
+
otherCount: z.ZodInt;
|
|
7867
|
+
}, z.core.$strip>;
|
|
7868
|
+
};
|
|
7869
|
+
LEASE_NOT_HELD: {
|
|
7870
|
+
readonly message: "The caller holds no such lease";
|
|
7871
|
+
readonly status: 409;
|
|
7872
|
+
};
|
|
5857
7873
|
AGENT_OUTDATED: {
|
|
5858
7874
|
readonly message: "The imp's agent is too old for this";
|
|
5859
7875
|
readonly status: 409;
|
|
@@ -5916,6 +7932,14 @@ declare const impContract: {
|
|
|
5916
7932
|
budgetMib: z.ZodInt;
|
|
5917
7933
|
usedMib: z.ZodInt;
|
|
5918
7934
|
requestedMib: z.ZodInt;
|
|
7935
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
7936
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7937
|
+
name: z.ZodString;
|
|
7938
|
+
ramMib: z.ZodInt;
|
|
7939
|
+
leased: z.ZodBoolean;
|
|
7940
|
+
busy: z.ZodBoolean;
|
|
7941
|
+
}, z.core.$strip>>>>;
|
|
7942
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
5919
7943
|
}, z.core.$strip>;
|
|
5920
7944
|
};
|
|
5921
7945
|
SERVICE_UNAVAILABLE: {
|
|
@@ -5950,6 +7974,26 @@ declare const impContract: {
|
|
|
5950
7974
|
requestedBytes: z.ZodInt;
|
|
5951
7975
|
}, z.core.$strip>;
|
|
5952
7976
|
};
|
|
7977
|
+
LEASED: {
|
|
7978
|
+
readonly message: "The imp is leased";
|
|
7979
|
+
readonly status: 409;
|
|
7980
|
+
readonly data: z.ZodObject<{
|
|
7981
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
7982
|
+
name: z.ZodString;
|
|
7983
|
+
owner: z.ZodObject<{
|
|
7984
|
+
principal: z.ZodString;
|
|
7985
|
+
display: z.ZodString;
|
|
7986
|
+
label: z.ZodString;
|
|
7987
|
+
}, z.core.$strip>;
|
|
7988
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
7989
|
+
}, z.core.$strip>>>;
|
|
7990
|
+
otherCount: z.ZodInt;
|
|
7991
|
+
}, z.core.$strip>;
|
|
7992
|
+
};
|
|
7993
|
+
LEASE_NOT_HELD: {
|
|
7994
|
+
readonly message: "The caller holds no such lease";
|
|
7995
|
+
readonly status: 409;
|
|
7996
|
+
};
|
|
5953
7997
|
AGENT_OUTDATED: {
|
|
5954
7998
|
readonly message: "The imp's agent is too old for this";
|
|
5955
7999
|
readonly status: 409;
|
|
@@ -6010,6 +8054,14 @@ declare const impContract: {
|
|
|
6010
8054
|
budgetMib: z.ZodInt;
|
|
6011
8055
|
usedMib: z.ZodInt;
|
|
6012
8056
|
requestedMib: z.ZodInt;
|
|
8057
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
8058
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8059
|
+
name: z.ZodString;
|
|
8060
|
+
ramMib: z.ZodInt;
|
|
8061
|
+
leased: z.ZodBoolean;
|
|
8062
|
+
busy: z.ZodBoolean;
|
|
8063
|
+
}, z.core.$strip>>>>;
|
|
8064
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
6013
8065
|
}, z.core.$strip>;
|
|
6014
8066
|
};
|
|
6015
8067
|
SERVICE_UNAVAILABLE: {
|
|
@@ -6044,6 +8096,26 @@ declare const impContract: {
|
|
|
6044
8096
|
requestedBytes: z.ZodInt;
|
|
6045
8097
|
}, z.core.$strip>;
|
|
6046
8098
|
};
|
|
8099
|
+
LEASED: {
|
|
8100
|
+
readonly message: "The imp is leased";
|
|
8101
|
+
readonly status: 409;
|
|
8102
|
+
readonly data: z.ZodObject<{
|
|
8103
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8104
|
+
name: z.ZodString;
|
|
8105
|
+
owner: z.ZodObject<{
|
|
8106
|
+
principal: z.ZodString;
|
|
8107
|
+
display: z.ZodString;
|
|
8108
|
+
label: z.ZodString;
|
|
8109
|
+
}, z.core.$strip>;
|
|
8110
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
8111
|
+
}, z.core.$strip>>>;
|
|
8112
|
+
otherCount: z.ZodInt;
|
|
8113
|
+
}, z.core.$strip>;
|
|
8114
|
+
};
|
|
8115
|
+
LEASE_NOT_HELD: {
|
|
8116
|
+
readonly message: "The caller holds no such lease";
|
|
8117
|
+
readonly status: 409;
|
|
8118
|
+
};
|
|
6047
8119
|
AGENT_OUTDATED: {
|
|
6048
8120
|
readonly message: "The imp's agent is too old for this";
|
|
6049
8121
|
readonly status: 409;
|
|
@@ -6103,6 +8175,14 @@ declare const impContract: {
|
|
|
6103
8175
|
budgetMib: z.ZodInt;
|
|
6104
8176
|
usedMib: z.ZodInt;
|
|
6105
8177
|
requestedMib: z.ZodInt;
|
|
8178
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
8179
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8180
|
+
name: z.ZodString;
|
|
8181
|
+
ramMib: z.ZodInt;
|
|
8182
|
+
leased: z.ZodBoolean;
|
|
8183
|
+
busy: z.ZodBoolean;
|
|
8184
|
+
}, z.core.$strip>>>>;
|
|
8185
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
6106
8186
|
}, z.core.$strip>;
|
|
6107
8187
|
};
|
|
6108
8188
|
SERVICE_UNAVAILABLE: {
|
|
@@ -6137,6 +8217,26 @@ declare const impContract: {
|
|
|
6137
8217
|
requestedBytes: z.ZodInt;
|
|
6138
8218
|
}, z.core.$strip>;
|
|
6139
8219
|
};
|
|
8220
|
+
LEASED: {
|
|
8221
|
+
readonly message: "The imp is leased";
|
|
8222
|
+
readonly status: 409;
|
|
8223
|
+
readonly data: z.ZodObject<{
|
|
8224
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8225
|
+
name: z.ZodString;
|
|
8226
|
+
owner: z.ZodObject<{
|
|
8227
|
+
principal: z.ZodString;
|
|
8228
|
+
display: z.ZodString;
|
|
8229
|
+
label: z.ZodString;
|
|
8230
|
+
}, z.core.$strip>;
|
|
8231
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
8232
|
+
}, z.core.$strip>>>;
|
|
8233
|
+
otherCount: z.ZodInt;
|
|
8234
|
+
}, z.core.$strip>;
|
|
8235
|
+
};
|
|
8236
|
+
LEASE_NOT_HELD: {
|
|
8237
|
+
readonly message: "The caller holds no such lease";
|
|
8238
|
+
readonly status: 409;
|
|
8239
|
+
};
|
|
6140
8240
|
AGENT_OUTDATED: {
|
|
6141
8241
|
readonly message: "The imp's agent is too old for this";
|
|
6142
8242
|
readonly status: 409;
|
|
@@ -6210,6 +8310,14 @@ declare const impContract: {
|
|
|
6210
8310
|
budgetMib: z.ZodInt;
|
|
6211
8311
|
usedMib: z.ZodInt;
|
|
6212
8312
|
requestedMib: z.ZodInt;
|
|
8313
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
8314
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8315
|
+
name: z.ZodString;
|
|
8316
|
+
ramMib: z.ZodInt;
|
|
8317
|
+
leased: z.ZodBoolean;
|
|
8318
|
+
busy: z.ZodBoolean;
|
|
8319
|
+
}, z.core.$strip>>>>;
|
|
8320
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
6213
8321
|
}, z.core.$strip>;
|
|
6214
8322
|
};
|
|
6215
8323
|
SERVICE_UNAVAILABLE: {
|
|
@@ -6244,6 +8352,26 @@ declare const impContract: {
|
|
|
6244
8352
|
requestedBytes: z.ZodInt;
|
|
6245
8353
|
}, z.core.$strip>;
|
|
6246
8354
|
};
|
|
8355
|
+
LEASED: {
|
|
8356
|
+
readonly message: "The imp is leased";
|
|
8357
|
+
readonly status: 409;
|
|
8358
|
+
readonly data: z.ZodObject<{
|
|
8359
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8360
|
+
name: z.ZodString;
|
|
8361
|
+
owner: z.ZodObject<{
|
|
8362
|
+
principal: z.ZodString;
|
|
8363
|
+
display: z.ZodString;
|
|
8364
|
+
label: z.ZodString;
|
|
8365
|
+
}, z.core.$strip>;
|
|
8366
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
8367
|
+
}, z.core.$strip>>>;
|
|
8368
|
+
otherCount: z.ZodInt;
|
|
8369
|
+
}, z.core.$strip>;
|
|
8370
|
+
};
|
|
8371
|
+
LEASE_NOT_HELD: {
|
|
8372
|
+
readonly message: "The caller holds no such lease";
|
|
8373
|
+
readonly status: 409;
|
|
8374
|
+
};
|
|
6247
8375
|
AGENT_OUTDATED: {
|
|
6248
8376
|
readonly message: "The imp's agent is too old for this";
|
|
6249
8377
|
readonly status: 409;
|
|
@@ -6317,6 +8445,14 @@ declare const impContract: {
|
|
|
6317
8445
|
budgetMib: z.ZodInt;
|
|
6318
8446
|
usedMib: z.ZodInt;
|
|
6319
8447
|
requestedMib: z.ZodInt;
|
|
8448
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
8449
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8450
|
+
name: z.ZodString;
|
|
8451
|
+
ramMib: z.ZodInt;
|
|
8452
|
+
leased: z.ZodBoolean;
|
|
8453
|
+
busy: z.ZodBoolean;
|
|
8454
|
+
}, z.core.$strip>>>>;
|
|
8455
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
6320
8456
|
}, z.core.$strip>;
|
|
6321
8457
|
};
|
|
6322
8458
|
SERVICE_UNAVAILABLE: {
|
|
@@ -6351,6 +8487,26 @@ declare const impContract: {
|
|
|
6351
8487
|
requestedBytes: z.ZodInt;
|
|
6352
8488
|
}, z.core.$strip>;
|
|
6353
8489
|
};
|
|
8490
|
+
LEASED: {
|
|
8491
|
+
readonly message: "The imp is leased";
|
|
8492
|
+
readonly status: 409;
|
|
8493
|
+
readonly data: z.ZodObject<{
|
|
8494
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
8495
|
+
name: z.ZodString;
|
|
8496
|
+
owner: z.ZodObject<{
|
|
8497
|
+
principal: z.ZodString;
|
|
8498
|
+
display: z.ZodString;
|
|
8499
|
+
label: z.ZodString;
|
|
8500
|
+
}, z.core.$strip>;
|
|
8501
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
8502
|
+
}, z.core.$strip>>>;
|
|
8503
|
+
otherCount: z.ZodInt;
|
|
8504
|
+
}, z.core.$strip>;
|
|
8505
|
+
};
|
|
8506
|
+
LEASE_NOT_HELD: {
|
|
8507
|
+
readonly message: "The caller holds no such lease";
|
|
8508
|
+
readonly status: 409;
|
|
8509
|
+
};
|
|
6354
8510
|
AGENT_OUTDATED: {
|
|
6355
8511
|
readonly message: "The imp's agent is too old for this";
|
|
6356
8512
|
readonly status: 409;
|
|
@@ -6392,6 +8548,18 @@ declare const impContract: {
|
|
|
6392
8548
|
rssMib?: number | undefined;
|
|
6393
8549
|
sleptAt?: Date | undefined;
|
|
6394
8550
|
holdUntil?: Date | undefined;
|
|
8551
|
+
leases?: {
|
|
8552
|
+
leases: readonly {
|
|
8553
|
+
name: string;
|
|
8554
|
+
owner: {
|
|
8555
|
+
principal: string;
|
|
8556
|
+
display: string;
|
|
8557
|
+
label: string;
|
|
8558
|
+
};
|
|
8559
|
+
until: Date | null;
|
|
8560
|
+
}[];
|
|
8561
|
+
otherCount: number;
|
|
8562
|
+
} | undefined;
|
|
6395
8563
|
error?: string | undefined;
|
|
6396
8564
|
sessions?: number | undefined;
|
|
6397
8565
|
coldBootReason?: string | undefined;
|
|
@@ -6418,7 +8586,7 @@ declare const impContract: {
|
|
|
6418
8586
|
v: 1;
|
|
6419
8587
|
at: Date;
|
|
6420
8588
|
ev: "ImpChanged";
|
|
6421
|
-
reason: "adopted" | "booted" | "exposed" | "failed" | "held" | "repaired" | "resized" | "restored" | "slept" | "stopped" | "updated" | "woke";
|
|
8589
|
+
reason: "adopted" | "booted" | "exposed" | "failed" | "held" | "released" | "repaired" | "resized" | "restored" | "slept" | "stopped" | "updated" | "woke";
|
|
6422
8590
|
imp: {
|
|
6423
8591
|
id: string;
|
|
6424
8592
|
name: string;
|
|
@@ -6448,6 +8616,18 @@ declare const impContract: {
|
|
|
6448
8616
|
rssMib?: number | undefined;
|
|
6449
8617
|
sleptAt?: Date | undefined;
|
|
6450
8618
|
holdUntil?: Date | undefined;
|
|
8619
|
+
leases?: {
|
|
8620
|
+
leases: readonly {
|
|
8621
|
+
name: string;
|
|
8622
|
+
owner: {
|
|
8623
|
+
principal: string;
|
|
8624
|
+
display: string;
|
|
8625
|
+
label: string;
|
|
8626
|
+
};
|
|
8627
|
+
until: Date | null;
|
|
8628
|
+
}[];
|
|
8629
|
+
otherCount: number;
|
|
8630
|
+
} | undefined;
|
|
6451
8631
|
error?: string | undefined;
|
|
6452
8632
|
sessions?: number | undefined;
|
|
6453
8633
|
coldBootReason?: string | undefined;
|
|
@@ -6475,6 +8655,7 @@ declare const impContract: {
|
|
|
6475
8655
|
trigger?: string | undefined;
|
|
6476
8656
|
coldBootReason?: string | undefined;
|
|
6477
8657
|
steps?: Readonly<Record<string, number>> | undefined;
|
|
8658
|
+
released?: number | undefined;
|
|
6478
8659
|
}> | undefined;
|
|
6479
8660
|
} | {
|
|
6480
8661
|
v: 1;
|
|
@@ -6509,6 +8690,18 @@ declare const impContract: {
|
|
|
6509
8690
|
rssMib?: number | undefined;
|
|
6510
8691
|
sleptAt?: Date | undefined;
|
|
6511
8692
|
holdUntil?: Date | undefined;
|
|
8693
|
+
leases?: {
|
|
8694
|
+
leases: readonly {
|
|
8695
|
+
name: string;
|
|
8696
|
+
owner: {
|
|
8697
|
+
principal: string;
|
|
8698
|
+
display: string;
|
|
8699
|
+
label: string;
|
|
8700
|
+
};
|
|
8701
|
+
until: Date | null;
|
|
8702
|
+
}[];
|
|
8703
|
+
otherCount: number;
|
|
8704
|
+
} | undefined;
|
|
6512
8705
|
error?: string | undefined;
|
|
6513
8706
|
sessions?: number | undefined;
|
|
6514
8707
|
coldBootReason?: string | undefined;
|
|
@@ -6565,6 +8758,8 @@ declare const impContract: {
|
|
|
6565
8758
|
usedMib: number;
|
|
6566
8759
|
budgetMib: number;
|
|
6567
8760
|
reserveMib?: number | undefined;
|
|
8761
|
+
neededMib?: number | undefined;
|
|
8762
|
+
protectedCount?: number | undefined;
|
|
6568
8763
|
}, unknown, void>, import("@orpc/client").AsyncIteratorClass<{
|
|
6569
8764
|
v: 1;
|
|
6570
8765
|
at: Date;
|
|
@@ -6599,6 +8794,18 @@ declare const impContract: {
|
|
|
6599
8794
|
rssMib?: number | undefined;
|
|
6600
8795
|
sleptAt?: Date | undefined;
|
|
6601
8796
|
holdUntil?: Date | undefined;
|
|
8797
|
+
leases?: {
|
|
8798
|
+
leases: readonly {
|
|
8799
|
+
name: string;
|
|
8800
|
+
owner: {
|
|
8801
|
+
principal: string;
|
|
8802
|
+
display: string;
|
|
8803
|
+
label: string;
|
|
8804
|
+
};
|
|
8805
|
+
until: Date | null;
|
|
8806
|
+
}[];
|
|
8807
|
+
otherCount: number;
|
|
8808
|
+
} | undefined;
|
|
6602
8809
|
error?: string | undefined;
|
|
6603
8810
|
sessions?: number | undefined;
|
|
6604
8811
|
coldBootReason?: string | undefined;
|
|
@@ -6625,7 +8832,7 @@ declare const impContract: {
|
|
|
6625
8832
|
v: 1;
|
|
6626
8833
|
at: Date;
|
|
6627
8834
|
ev: "ImpChanged";
|
|
6628
|
-
reason: "adopted" | "booted" | "exposed" | "failed" | "held" | "repaired" | "resized" | "restored" | "slept" | "stopped" | "updated" | "woke";
|
|
8835
|
+
reason: "adopted" | "booted" | "exposed" | "failed" | "held" | "released" | "repaired" | "resized" | "restored" | "slept" | "stopped" | "updated" | "woke";
|
|
6629
8836
|
imp: {
|
|
6630
8837
|
id: string;
|
|
6631
8838
|
name: string;
|
|
@@ -6655,6 +8862,18 @@ declare const impContract: {
|
|
|
6655
8862
|
rssMib?: number | undefined;
|
|
6656
8863
|
sleptAt?: Date | undefined;
|
|
6657
8864
|
holdUntil?: Date | undefined;
|
|
8865
|
+
leases?: {
|
|
8866
|
+
leases: readonly {
|
|
8867
|
+
name: string;
|
|
8868
|
+
owner: {
|
|
8869
|
+
principal: string;
|
|
8870
|
+
display: string;
|
|
8871
|
+
label: string;
|
|
8872
|
+
};
|
|
8873
|
+
until: Date | null;
|
|
8874
|
+
}[];
|
|
8875
|
+
otherCount: number;
|
|
8876
|
+
} | undefined;
|
|
6658
8877
|
error?: string | undefined;
|
|
6659
8878
|
sessions?: number | undefined;
|
|
6660
8879
|
coldBootReason?: string | undefined;
|
|
@@ -6682,6 +8901,7 @@ declare const impContract: {
|
|
|
6682
8901
|
trigger?: string | undefined;
|
|
6683
8902
|
coldBootReason?: string | undefined;
|
|
6684
8903
|
steps?: Readonly<Record<string, number>> | undefined;
|
|
8904
|
+
released?: number | undefined;
|
|
6685
8905
|
}> | undefined;
|
|
6686
8906
|
} | {
|
|
6687
8907
|
v: 1;
|
|
@@ -6716,6 +8936,18 @@ declare const impContract: {
|
|
|
6716
8936
|
rssMib?: number | undefined;
|
|
6717
8937
|
sleptAt?: Date | undefined;
|
|
6718
8938
|
holdUntil?: Date | undefined;
|
|
8939
|
+
leases?: {
|
|
8940
|
+
leases: readonly {
|
|
8941
|
+
name: string;
|
|
8942
|
+
owner: {
|
|
8943
|
+
principal: string;
|
|
8944
|
+
display: string;
|
|
8945
|
+
label: string;
|
|
8946
|
+
};
|
|
8947
|
+
until: Date | null;
|
|
8948
|
+
}[];
|
|
8949
|
+
otherCount: number;
|
|
8950
|
+
} | undefined;
|
|
6719
8951
|
error?: string | undefined;
|
|
6720
8952
|
sessions?: number | undefined;
|
|
6721
8953
|
coldBootReason?: string | undefined;
|
|
@@ -6772,6 +9004,8 @@ declare const impContract: {
|
|
|
6772
9004
|
usedMib: number;
|
|
6773
9005
|
budgetMib: number;
|
|
6774
9006
|
reserveMib?: number | undefined;
|
|
9007
|
+
neededMib?: number | undefined;
|
|
9008
|
+
protectedCount?: number | undefined;
|
|
6775
9009
|
}, unknown, void>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
6776
9010
|
NOT_FOUND: {
|
|
6777
9011
|
readonly message: "Not found";
|
|
@@ -6824,6 +9058,14 @@ declare const impContract: {
|
|
|
6824
9058
|
budgetMib: z.ZodInt;
|
|
6825
9059
|
usedMib: z.ZodInt;
|
|
6826
9060
|
requestedMib: z.ZodInt;
|
|
9061
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9062
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9063
|
+
name: z.ZodString;
|
|
9064
|
+
ramMib: z.ZodInt;
|
|
9065
|
+
leased: z.ZodBoolean;
|
|
9066
|
+
busy: z.ZodBoolean;
|
|
9067
|
+
}, z.core.$strip>>>>;
|
|
9068
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
6827
9069
|
}, z.core.$strip>;
|
|
6828
9070
|
};
|
|
6829
9071
|
SERVICE_UNAVAILABLE: {
|
|
@@ -6858,6 +9100,26 @@ declare const impContract: {
|
|
|
6858
9100
|
requestedBytes: z.ZodInt;
|
|
6859
9101
|
}, z.core.$strip>;
|
|
6860
9102
|
};
|
|
9103
|
+
LEASED: {
|
|
9104
|
+
readonly message: "The imp is leased";
|
|
9105
|
+
readonly status: 409;
|
|
9106
|
+
readonly data: z.ZodObject<{
|
|
9107
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9108
|
+
name: z.ZodString;
|
|
9109
|
+
owner: z.ZodObject<{
|
|
9110
|
+
principal: z.ZodString;
|
|
9111
|
+
display: z.ZodString;
|
|
9112
|
+
label: z.ZodString;
|
|
9113
|
+
}, z.core.$strip>;
|
|
9114
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9115
|
+
}, z.core.$strip>>>;
|
|
9116
|
+
otherCount: z.ZodInt;
|
|
9117
|
+
}, z.core.$strip>;
|
|
9118
|
+
};
|
|
9119
|
+
LEASE_NOT_HELD: {
|
|
9120
|
+
readonly message: "The caller holds no such lease";
|
|
9121
|
+
readonly status: 409;
|
|
9122
|
+
};
|
|
6861
9123
|
AGENT_OUTDATED: {
|
|
6862
9124
|
readonly message: "The imp's agent is too old for this";
|
|
6863
9125
|
readonly status: 409;
|
|
@@ -6929,6 +9191,10 @@ declare const impContract: {
|
|
|
6929
9191
|
at: z.ZodDate;
|
|
6930
9192
|
}, z.core.$strip>>;
|
|
6931
9193
|
}, z.core.$strip>>>;
|
|
9194
|
+
features: z.ZodOptional<z.ZodObject<{
|
|
9195
|
+
sessionOffsets: z.ZodBoolean;
|
|
9196
|
+
leases: z.ZodBoolean;
|
|
9197
|
+
}, z.core.$strip>>;
|
|
6932
9198
|
}, z.core.$strip>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
6933
9199
|
NOT_FOUND: {
|
|
6934
9200
|
readonly message: "Not found";
|
|
@@ -6981,6 +9247,14 @@ declare const impContract: {
|
|
|
6981
9247
|
budgetMib: z.ZodInt;
|
|
6982
9248
|
usedMib: z.ZodInt;
|
|
6983
9249
|
requestedMib: z.ZodInt;
|
|
9250
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9251
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9252
|
+
name: z.ZodString;
|
|
9253
|
+
ramMib: z.ZodInt;
|
|
9254
|
+
leased: z.ZodBoolean;
|
|
9255
|
+
busy: z.ZodBoolean;
|
|
9256
|
+
}, z.core.$strip>>>>;
|
|
9257
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
6984
9258
|
}, z.core.$strip>;
|
|
6985
9259
|
};
|
|
6986
9260
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7015,6 +9289,26 @@ declare const impContract: {
|
|
|
7015
9289
|
requestedBytes: z.ZodInt;
|
|
7016
9290
|
}, z.core.$strip>;
|
|
7017
9291
|
};
|
|
9292
|
+
LEASED: {
|
|
9293
|
+
readonly message: "The imp is leased";
|
|
9294
|
+
readonly status: 409;
|
|
9295
|
+
readonly data: z.ZodObject<{
|
|
9296
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9297
|
+
name: z.ZodString;
|
|
9298
|
+
owner: z.ZodObject<{
|
|
9299
|
+
principal: z.ZodString;
|
|
9300
|
+
display: z.ZodString;
|
|
9301
|
+
label: z.ZodString;
|
|
9302
|
+
}, z.core.$strip>;
|
|
9303
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9304
|
+
}, z.core.$strip>>>;
|
|
9305
|
+
otherCount: z.ZodInt;
|
|
9306
|
+
}, z.core.$strip>;
|
|
9307
|
+
};
|
|
9308
|
+
LEASE_NOT_HELD: {
|
|
9309
|
+
readonly message: "The caller holds no such lease";
|
|
9310
|
+
readonly status: 409;
|
|
9311
|
+
};
|
|
7018
9312
|
AGENT_OUTDATED: {
|
|
7019
9313
|
readonly message: "The imp's agent is too old for this";
|
|
7020
9314
|
readonly status: 409;
|
|
@@ -7022,6 +9316,7 @@ declare const impContract: {
|
|
|
7022
9316
|
}>, Record<never, never>>;
|
|
7023
9317
|
gc: import("@orpc/contract").ContractProcedureBuilderWithInputOutput<z.ZodObject<{
|
|
7024
9318
|
dryRun: z.ZodOptional<z.ZodBoolean>;
|
|
9319
|
+
orphans: z.ZodOptional<z.ZodBoolean>;
|
|
7025
9320
|
}, z.core.$strip>, z.ZodReadonly<z.ZodObject<{
|
|
7026
9321
|
dryRun: z.ZodBoolean;
|
|
7027
9322
|
dropped: z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
|
|
@@ -7034,6 +9329,19 @@ declare const impContract: {
|
|
|
7034
9329
|
}>;
|
|
7035
9330
|
id: z.ZodString;
|
|
7036
9331
|
}, z.core.$strip>>>>;
|
|
9332
|
+
kept: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodObject<{
|
|
9333
|
+
kind: z.ZodEnum<{
|
|
9334
|
+
checkpoint: "checkpoint";
|
|
9335
|
+
image: "image";
|
|
9336
|
+
imp: "imp";
|
|
9337
|
+
memory: "memory";
|
|
9338
|
+
}>;
|
|
9339
|
+
id: z.ZodString;
|
|
9340
|
+
location: z.ZodString;
|
|
9341
|
+
bytes: z.ZodInt;
|
|
9342
|
+
createdAt: z.ZodNullable<z.ZodDate>;
|
|
9343
|
+
snapshots: z.ZodReadonly<z.ZodArray<z.ZodString>>;
|
|
9344
|
+
}, z.core.$strip>>>>>;
|
|
7037
9345
|
}, z.core.$strip>>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
|
|
7038
9346
|
NOT_FOUND: {
|
|
7039
9347
|
readonly message: "Not found";
|
|
@@ -7086,6 +9394,14 @@ declare const impContract: {
|
|
|
7086
9394
|
budgetMib: z.ZodInt;
|
|
7087
9395
|
usedMib: z.ZodInt;
|
|
7088
9396
|
requestedMib: z.ZodInt;
|
|
9397
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9398
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9399
|
+
name: z.ZodString;
|
|
9400
|
+
ramMib: z.ZodInt;
|
|
9401
|
+
leased: z.ZodBoolean;
|
|
9402
|
+
busy: z.ZodBoolean;
|
|
9403
|
+
}, z.core.$strip>>>>;
|
|
9404
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7089
9405
|
}, z.core.$strip>;
|
|
7090
9406
|
};
|
|
7091
9407
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7120,6 +9436,26 @@ declare const impContract: {
|
|
|
7120
9436
|
requestedBytes: z.ZodInt;
|
|
7121
9437
|
}, z.core.$strip>;
|
|
7122
9438
|
};
|
|
9439
|
+
LEASED: {
|
|
9440
|
+
readonly message: "The imp is leased";
|
|
9441
|
+
readonly status: 409;
|
|
9442
|
+
readonly data: z.ZodObject<{
|
|
9443
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9444
|
+
name: z.ZodString;
|
|
9445
|
+
owner: z.ZodObject<{
|
|
9446
|
+
principal: z.ZodString;
|
|
9447
|
+
display: z.ZodString;
|
|
9448
|
+
label: z.ZodString;
|
|
9449
|
+
}, z.core.$strip>;
|
|
9450
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9451
|
+
}, z.core.$strip>>>;
|
|
9452
|
+
otherCount: z.ZodInt;
|
|
9453
|
+
}, z.core.$strip>;
|
|
9454
|
+
};
|
|
9455
|
+
LEASE_NOT_HELD: {
|
|
9456
|
+
readonly message: "The caller holds no such lease";
|
|
9457
|
+
readonly status: 409;
|
|
9458
|
+
};
|
|
7123
9459
|
AGENT_OUTDATED: {
|
|
7124
9460
|
readonly message: "The imp's agent is too old for this";
|
|
7125
9461
|
readonly status: 409;
|
|
@@ -7193,6 +9529,14 @@ declare const impContract: {
|
|
|
7193
9529
|
budgetMib: z.ZodInt;
|
|
7194
9530
|
usedMib: z.ZodInt;
|
|
7195
9531
|
requestedMib: z.ZodInt;
|
|
9532
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9533
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9534
|
+
name: z.ZodString;
|
|
9535
|
+
ramMib: z.ZodInt;
|
|
9536
|
+
leased: z.ZodBoolean;
|
|
9537
|
+
busy: z.ZodBoolean;
|
|
9538
|
+
}, z.core.$strip>>>>;
|
|
9539
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7196
9540
|
}, z.core.$strip>;
|
|
7197
9541
|
};
|
|
7198
9542
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7227,6 +9571,26 @@ declare const impContract: {
|
|
|
7227
9571
|
requestedBytes: z.ZodInt;
|
|
7228
9572
|
}, z.core.$strip>;
|
|
7229
9573
|
};
|
|
9574
|
+
LEASED: {
|
|
9575
|
+
readonly message: "The imp is leased";
|
|
9576
|
+
readonly status: 409;
|
|
9577
|
+
readonly data: z.ZodObject<{
|
|
9578
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9579
|
+
name: z.ZodString;
|
|
9580
|
+
owner: z.ZodObject<{
|
|
9581
|
+
principal: z.ZodString;
|
|
9582
|
+
display: z.ZodString;
|
|
9583
|
+
label: z.ZodString;
|
|
9584
|
+
}, z.core.$strip>;
|
|
9585
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9586
|
+
}, z.core.$strip>>>;
|
|
9587
|
+
otherCount: z.ZodInt;
|
|
9588
|
+
}, z.core.$strip>;
|
|
9589
|
+
};
|
|
9590
|
+
LEASE_NOT_HELD: {
|
|
9591
|
+
readonly message: "The caller holds no such lease";
|
|
9592
|
+
readonly status: 409;
|
|
9593
|
+
};
|
|
7230
9594
|
AGENT_OUTDATED: {
|
|
7231
9595
|
readonly message: "The imp's agent is too old for this";
|
|
7232
9596
|
readonly status: 409;
|
|
@@ -7310,6 +9674,14 @@ declare const impContract: {
|
|
|
7310
9674
|
budgetMib: z.ZodInt;
|
|
7311
9675
|
usedMib: z.ZodInt;
|
|
7312
9676
|
requestedMib: z.ZodInt;
|
|
9677
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9678
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9679
|
+
name: z.ZodString;
|
|
9680
|
+
ramMib: z.ZodInt;
|
|
9681
|
+
leased: z.ZodBoolean;
|
|
9682
|
+
busy: z.ZodBoolean;
|
|
9683
|
+
}, z.core.$strip>>>>;
|
|
9684
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7313
9685
|
}, z.core.$strip>;
|
|
7314
9686
|
};
|
|
7315
9687
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7344,6 +9716,26 @@ declare const impContract: {
|
|
|
7344
9716
|
requestedBytes: z.ZodInt;
|
|
7345
9717
|
}, z.core.$strip>;
|
|
7346
9718
|
};
|
|
9719
|
+
LEASED: {
|
|
9720
|
+
readonly message: "The imp is leased";
|
|
9721
|
+
readonly status: 409;
|
|
9722
|
+
readonly data: z.ZodObject<{
|
|
9723
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9724
|
+
name: z.ZodString;
|
|
9725
|
+
owner: z.ZodObject<{
|
|
9726
|
+
principal: z.ZodString;
|
|
9727
|
+
display: z.ZodString;
|
|
9728
|
+
label: z.ZodString;
|
|
9729
|
+
}, z.core.$strip>;
|
|
9730
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9731
|
+
}, z.core.$strip>>>;
|
|
9732
|
+
otherCount: z.ZodInt;
|
|
9733
|
+
}, z.core.$strip>;
|
|
9734
|
+
};
|
|
9735
|
+
LEASE_NOT_HELD: {
|
|
9736
|
+
readonly message: "The caller holds no such lease";
|
|
9737
|
+
readonly status: 409;
|
|
9738
|
+
};
|
|
7347
9739
|
AGENT_OUTDATED: {
|
|
7348
9740
|
readonly message: "The imp's agent is too old for this";
|
|
7349
9741
|
readonly status: 409;
|
|
@@ -7403,6 +9795,14 @@ declare const impContract: {
|
|
|
7403
9795
|
budgetMib: z.ZodInt;
|
|
7404
9796
|
usedMib: z.ZodInt;
|
|
7405
9797
|
requestedMib: z.ZodInt;
|
|
9798
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9799
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9800
|
+
name: z.ZodString;
|
|
9801
|
+
ramMib: z.ZodInt;
|
|
9802
|
+
leased: z.ZodBoolean;
|
|
9803
|
+
busy: z.ZodBoolean;
|
|
9804
|
+
}, z.core.$strip>>>>;
|
|
9805
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7406
9806
|
}, z.core.$strip>;
|
|
7407
9807
|
};
|
|
7408
9808
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7437,6 +9837,26 @@ declare const impContract: {
|
|
|
7437
9837
|
requestedBytes: z.ZodInt;
|
|
7438
9838
|
}, z.core.$strip>;
|
|
7439
9839
|
};
|
|
9840
|
+
LEASED: {
|
|
9841
|
+
readonly message: "The imp is leased";
|
|
9842
|
+
readonly status: 409;
|
|
9843
|
+
readonly data: z.ZodObject<{
|
|
9844
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9845
|
+
name: z.ZodString;
|
|
9846
|
+
owner: z.ZodObject<{
|
|
9847
|
+
principal: z.ZodString;
|
|
9848
|
+
display: z.ZodString;
|
|
9849
|
+
label: z.ZodString;
|
|
9850
|
+
}, z.core.$strip>;
|
|
9851
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9852
|
+
}, z.core.$strip>>>;
|
|
9853
|
+
otherCount: z.ZodInt;
|
|
9854
|
+
}, z.core.$strip>;
|
|
9855
|
+
};
|
|
9856
|
+
LEASE_NOT_HELD: {
|
|
9857
|
+
readonly message: "The caller holds no such lease";
|
|
9858
|
+
readonly status: 409;
|
|
9859
|
+
};
|
|
7440
9860
|
AGENT_OUTDATED: {
|
|
7441
9861
|
readonly message: "The imp's agent is too old for this";
|
|
7442
9862
|
readonly status: 409;
|
|
@@ -7501,6 +9921,14 @@ declare const impContract: {
|
|
|
7501
9921
|
budgetMib: z.ZodInt;
|
|
7502
9922
|
usedMib: z.ZodInt;
|
|
7503
9923
|
requestedMib: z.ZodInt;
|
|
9924
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
9925
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9926
|
+
name: z.ZodString;
|
|
9927
|
+
ramMib: z.ZodInt;
|
|
9928
|
+
leased: z.ZodBoolean;
|
|
9929
|
+
busy: z.ZodBoolean;
|
|
9930
|
+
}, z.core.$strip>>>>;
|
|
9931
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7504
9932
|
}, z.core.$strip>;
|
|
7505
9933
|
};
|
|
7506
9934
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7535,6 +9963,26 @@ declare const impContract: {
|
|
|
7535
9963
|
requestedBytes: z.ZodInt;
|
|
7536
9964
|
}, z.core.$strip>;
|
|
7537
9965
|
};
|
|
9966
|
+
LEASED: {
|
|
9967
|
+
readonly message: "The imp is leased";
|
|
9968
|
+
readonly status: 409;
|
|
9969
|
+
readonly data: z.ZodObject<{
|
|
9970
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
9971
|
+
name: z.ZodString;
|
|
9972
|
+
owner: z.ZodObject<{
|
|
9973
|
+
principal: z.ZodString;
|
|
9974
|
+
display: z.ZodString;
|
|
9975
|
+
label: z.ZodString;
|
|
9976
|
+
}, z.core.$strip>;
|
|
9977
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
9978
|
+
}, z.core.$strip>>>;
|
|
9979
|
+
otherCount: z.ZodInt;
|
|
9980
|
+
}, z.core.$strip>;
|
|
9981
|
+
};
|
|
9982
|
+
LEASE_NOT_HELD: {
|
|
9983
|
+
readonly message: "The caller holds no such lease";
|
|
9984
|
+
readonly status: 409;
|
|
9985
|
+
};
|
|
7538
9986
|
AGENT_OUTDATED: {
|
|
7539
9987
|
readonly message: "The imp's agent is too old for this";
|
|
7540
9988
|
readonly status: 409;
|
|
@@ -7595,6 +10043,14 @@ declare const impContract: {
|
|
|
7595
10043
|
budgetMib: z.ZodInt;
|
|
7596
10044
|
usedMib: z.ZodInt;
|
|
7597
10045
|
requestedMib: z.ZodInt;
|
|
10046
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
10047
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
10048
|
+
name: z.ZodString;
|
|
10049
|
+
ramMib: z.ZodInt;
|
|
10050
|
+
leased: z.ZodBoolean;
|
|
10051
|
+
busy: z.ZodBoolean;
|
|
10052
|
+
}, z.core.$strip>>>>;
|
|
10053
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7598
10054
|
}, z.core.$strip>;
|
|
7599
10055
|
};
|
|
7600
10056
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7629,6 +10085,26 @@ declare const impContract: {
|
|
|
7629
10085
|
requestedBytes: z.ZodInt;
|
|
7630
10086
|
}, z.core.$strip>;
|
|
7631
10087
|
};
|
|
10088
|
+
LEASED: {
|
|
10089
|
+
readonly message: "The imp is leased";
|
|
10090
|
+
readonly status: 409;
|
|
10091
|
+
readonly data: z.ZodObject<{
|
|
10092
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
10093
|
+
name: z.ZodString;
|
|
10094
|
+
owner: z.ZodObject<{
|
|
10095
|
+
principal: z.ZodString;
|
|
10096
|
+
display: z.ZodString;
|
|
10097
|
+
label: z.ZodString;
|
|
10098
|
+
}, z.core.$strip>;
|
|
10099
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
10100
|
+
}, z.core.$strip>>>;
|
|
10101
|
+
otherCount: z.ZodInt;
|
|
10102
|
+
}, z.core.$strip>;
|
|
10103
|
+
};
|
|
10104
|
+
LEASE_NOT_HELD: {
|
|
10105
|
+
readonly message: "The caller holds no such lease";
|
|
10106
|
+
readonly status: 409;
|
|
10107
|
+
};
|
|
7632
10108
|
AGENT_OUTDATED: {
|
|
7633
10109
|
readonly message: "The imp's agent is too old for this";
|
|
7634
10110
|
readonly status: 409;
|
|
@@ -7700,6 +10176,14 @@ declare const impContract: {
|
|
|
7700
10176
|
budgetMib: z.ZodInt;
|
|
7701
10177
|
usedMib: z.ZodInt;
|
|
7702
10178
|
requestedMib: z.ZodInt;
|
|
10179
|
+
neededMib: z.ZodOptional<z.ZodInt>;
|
|
10180
|
+
protected: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
10181
|
+
name: z.ZodString;
|
|
10182
|
+
ramMib: z.ZodInt;
|
|
10183
|
+
leased: z.ZodBoolean;
|
|
10184
|
+
busy: z.ZodBoolean;
|
|
10185
|
+
}, z.core.$strip>>>>;
|
|
10186
|
+
protectedHidden: z.ZodOptional<z.ZodInt>;
|
|
7703
10187
|
}, z.core.$strip>;
|
|
7704
10188
|
};
|
|
7705
10189
|
SERVICE_UNAVAILABLE: {
|
|
@@ -7734,6 +10218,26 @@ declare const impContract: {
|
|
|
7734
10218
|
requestedBytes: z.ZodInt;
|
|
7735
10219
|
}, z.core.$strip>;
|
|
7736
10220
|
};
|
|
10221
|
+
LEASED: {
|
|
10222
|
+
readonly message: "The imp is leased";
|
|
10223
|
+
readonly status: 409;
|
|
10224
|
+
readonly data: z.ZodObject<{
|
|
10225
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
10226
|
+
name: z.ZodString;
|
|
10227
|
+
owner: z.ZodObject<{
|
|
10228
|
+
principal: z.ZodString;
|
|
10229
|
+
display: z.ZodString;
|
|
10230
|
+
label: z.ZodString;
|
|
10231
|
+
}, z.core.$strip>;
|
|
10232
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
10233
|
+
}, z.core.$strip>>>;
|
|
10234
|
+
otherCount: z.ZodInt;
|
|
10235
|
+
}, z.core.$strip>;
|
|
10236
|
+
};
|
|
10237
|
+
LEASE_NOT_HELD: {
|
|
10238
|
+
readonly message: "The caller holds no such lease";
|
|
10239
|
+
readonly status: 409;
|
|
10240
|
+
};
|
|
7737
10241
|
AGENT_OUTDATED: {
|
|
7738
10242
|
readonly message: "The imp's agent is too old for this";
|
|
7739
10243
|
readonly status: 409;
|
|
@@ -7791,6 +10295,18 @@ declare const ImpSchema: z.ZodObject<{
|
|
|
7791
10295
|
rssMib: z.ZodOptional<z.ZodInt>;
|
|
7792
10296
|
sleptAt: z.ZodOptional<z.ZodDate>;
|
|
7793
10297
|
holdUntil: z.ZodOptional<z.ZodDate>;
|
|
10298
|
+
leases: z.ZodOptional<z.ZodObject<{
|
|
10299
|
+
leases: z.ZodReadonly<z.ZodArray<z.ZodObject<{
|
|
10300
|
+
name: z.ZodString;
|
|
10301
|
+
owner: z.ZodObject<{
|
|
10302
|
+
principal: z.ZodString;
|
|
10303
|
+
display: z.ZodString;
|
|
10304
|
+
label: z.ZodString;
|
|
10305
|
+
}, z.core.$strip>;
|
|
10306
|
+
until: z.ZodNullable<z.ZodDate>;
|
|
10307
|
+
}, z.core.$strip>>>;
|
|
10308
|
+
otherCount: z.ZodInt;
|
|
10309
|
+
}, z.core.$strip>>;
|
|
7794
10310
|
error: z.ZodOptional<z.ZodString>;
|
|
7795
10311
|
sessions: z.ZodOptional<z.ZodInt>;
|
|
7796
10312
|
coldBootReason: z.ZodOptional<z.ZodString>;
|
|
@@ -7909,6 +10425,10 @@ declare const SystemInfoSchema: z.ZodObject<{
|
|
|
7909
10425
|
at: z.ZodDate;
|
|
7910
10426
|
}, z.core.$strip>>;
|
|
7911
10427
|
}, z.core.$strip>>>;
|
|
10428
|
+
features: z.ZodOptional<z.ZodObject<{
|
|
10429
|
+
sessionOffsets: z.ZodBoolean;
|
|
10430
|
+
leases: z.ZodBoolean;
|
|
10431
|
+
}, z.core.$strip>>;
|
|
7912
10432
|
}, z.core.$strip>;
|
|
7913
10433
|
type SystemInfo = z.infer<typeof SystemInfoSchema>;
|
|
7914
10434
|
//#endregion
|