@osstack/protocol 0.10.0 → 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/LICENSE +21 -0
- package/dist/autonomy.d.ts +1300 -0
- package/dist/autonomy.d.ts.map +1 -0
- package/dist/autonomy.js +270 -0
- package/dist/autonomy.js.map +1 -0
- package/dist/envelope.d.ts +8 -8
- package/dist/event.d.ts +2 -2
- package/dist/generate.d.ts +1 -1
- package/dist/generate.d.ts.map +1 -1
- package/dist/generate.js +30 -1
- package/dist/generate.js.map +1 -1
- package/dist/index.d.ts +1 -0
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +1 -0
- package/dist/index.js.map +1 -1
- package/dist/run.d.ts +2 -2
- package/package.json +9 -9
- package/schemas/autonomy-risk-decision.schema.json +86 -0
- package/schemas/autonomy-risk-level.schema.json +12 -0
- package/schemas/autonomy-run-state.schema.json +35 -0
- package/schemas/scoped-approval-decision.schema.json +131 -0
- package/schemas/scoped-approval-request.schema.json +73 -0
- package/dist/protocol.test.d.ts +0 -2
- package/dist/protocol.test.d.ts.map +0 -1
- package/dist/protocol.test.js +0 -251
- package/dist/protocol.test.js.map +0 -1
- package/dist/schemas.test.d.ts +0 -2
- package/dist/schemas.test.d.ts.map +0 -1
- package/dist/schemas.test.js +0 -34
- package/dist/schemas.test.js.map +0 -1
|
@@ -0,0 +1,1300 @@
|
|
|
1
|
+
import { z } from "zod";
|
|
2
|
+
/**
|
|
3
|
+
* SHA-256 of an empty byte string. Preflight RISK-R3 approval binds this
|
|
4
|
+
* sentinel because no authoritative staged diff exists before Builder runs.
|
|
5
|
+
*/
|
|
6
|
+
export declare const AUTONOMY_EMPTY_DIFF_SHA256: "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
|
|
7
|
+
export declare const AutonomyRiskLevel: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
8
|
+
export type AutonomyRiskLevel = z.infer<typeof AutonomyRiskLevel>;
|
|
9
|
+
export declare const AutonomyRiskPhase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
10
|
+
export type AutonomyRiskPhase = z.infer<typeof AutonomyRiskPhase>;
|
|
11
|
+
export declare const AutonomyRiskSignal: z.ZodObject<{
|
|
12
|
+
readonly rule_id: z.ZodString;
|
|
13
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
14
|
+
readonly message: z.ZodString;
|
|
15
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
16
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
17
|
+
}, "strict", z.ZodTypeAny, {
|
|
18
|
+
message: string;
|
|
19
|
+
rule_id: string;
|
|
20
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
21
|
+
path?: string | undefined;
|
|
22
|
+
command?: string | undefined;
|
|
23
|
+
}, {
|
|
24
|
+
message: string;
|
|
25
|
+
rule_id: string;
|
|
26
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
27
|
+
path?: string | undefined;
|
|
28
|
+
command?: string | undefined;
|
|
29
|
+
}>;
|
|
30
|
+
export type AutonomyRiskSignal = z.infer<typeof AutonomyRiskSignal>;
|
|
31
|
+
export declare const AutonomyRiskSignalLenient: z.ZodObject<{
|
|
32
|
+
readonly rule_id: z.ZodString;
|
|
33
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
34
|
+
readonly message: z.ZodString;
|
|
35
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
36
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
37
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
38
|
+
readonly rule_id: z.ZodString;
|
|
39
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
40
|
+
readonly message: z.ZodString;
|
|
41
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
42
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
43
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
44
|
+
readonly rule_id: z.ZodString;
|
|
45
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
46
|
+
readonly message: z.ZodString;
|
|
47
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
48
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
49
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
50
|
+
export declare const AutonomyRiskDecision: z.ZodEffects<z.ZodObject<{
|
|
51
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
52
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
53
|
+
readonly signals: z.ZodArray<z.ZodObject<{
|
|
54
|
+
readonly rule_id: z.ZodString;
|
|
55
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
56
|
+
readonly message: z.ZodString;
|
|
57
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
58
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
59
|
+
}, "strict", z.ZodTypeAny, {
|
|
60
|
+
message: string;
|
|
61
|
+
rule_id: string;
|
|
62
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
63
|
+
path?: string | undefined;
|
|
64
|
+
command?: string | undefined;
|
|
65
|
+
}, {
|
|
66
|
+
message: string;
|
|
67
|
+
rule_id: string;
|
|
68
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
69
|
+
path?: string | undefined;
|
|
70
|
+
command?: string | undefined;
|
|
71
|
+
}>, "many">;
|
|
72
|
+
readonly policy_sha256: z.ZodString;
|
|
73
|
+
readonly input_sha256: z.ZodString;
|
|
74
|
+
readonly decided_at: z.ZodString;
|
|
75
|
+
}, "strict", z.ZodTypeAny, {
|
|
76
|
+
decided_at: string;
|
|
77
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
78
|
+
signals: {
|
|
79
|
+
message: string;
|
|
80
|
+
rule_id: string;
|
|
81
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
82
|
+
path?: string | undefined;
|
|
83
|
+
command?: string | undefined;
|
|
84
|
+
}[];
|
|
85
|
+
phase: "preflight" | "post_diff";
|
|
86
|
+
policy_sha256: string;
|
|
87
|
+
input_sha256: string;
|
|
88
|
+
}, {
|
|
89
|
+
decided_at: string;
|
|
90
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
91
|
+
signals: {
|
|
92
|
+
message: string;
|
|
93
|
+
rule_id: string;
|
|
94
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
95
|
+
path?: string | undefined;
|
|
96
|
+
command?: string | undefined;
|
|
97
|
+
}[];
|
|
98
|
+
phase: "preflight" | "post_diff";
|
|
99
|
+
policy_sha256: string;
|
|
100
|
+
input_sha256: string;
|
|
101
|
+
}>, {
|
|
102
|
+
decided_at: string;
|
|
103
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
104
|
+
signals: {
|
|
105
|
+
message: string;
|
|
106
|
+
rule_id: string;
|
|
107
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
108
|
+
path?: string | undefined;
|
|
109
|
+
command?: string | undefined;
|
|
110
|
+
}[];
|
|
111
|
+
phase: "preflight" | "post_diff";
|
|
112
|
+
policy_sha256: string;
|
|
113
|
+
input_sha256: string;
|
|
114
|
+
}, {
|
|
115
|
+
decided_at: string;
|
|
116
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
117
|
+
signals: {
|
|
118
|
+
message: string;
|
|
119
|
+
rule_id: string;
|
|
120
|
+
level: "R0" | "R1" | "R2" | "R3" | "R4";
|
|
121
|
+
path?: string | undefined;
|
|
122
|
+
command?: string | undefined;
|
|
123
|
+
}[];
|
|
124
|
+
phase: "preflight" | "post_diff";
|
|
125
|
+
policy_sha256: string;
|
|
126
|
+
input_sha256: string;
|
|
127
|
+
}>;
|
|
128
|
+
export type AutonomyRiskDecision = z.infer<typeof AutonomyRiskDecision>;
|
|
129
|
+
export declare const AutonomyRiskDecisionLenient: z.ZodEffects<z.ZodObject<{
|
|
130
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
131
|
+
readonly rule_id: z.ZodString;
|
|
132
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
133
|
+
readonly message: z.ZodString;
|
|
134
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
135
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
136
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
137
|
+
readonly rule_id: z.ZodString;
|
|
138
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
139
|
+
readonly message: z.ZodString;
|
|
140
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
141
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
142
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
143
|
+
readonly rule_id: z.ZodString;
|
|
144
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
145
|
+
readonly message: z.ZodString;
|
|
146
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
147
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
148
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
149
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
150
|
+
level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
151
|
+
policy_sha256: z.ZodString;
|
|
152
|
+
input_sha256: z.ZodString;
|
|
153
|
+
decided_at: z.ZodString;
|
|
154
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
155
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
156
|
+
readonly rule_id: z.ZodString;
|
|
157
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
158
|
+
readonly message: z.ZodString;
|
|
159
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
160
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
161
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
162
|
+
readonly rule_id: z.ZodString;
|
|
163
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
164
|
+
readonly message: z.ZodString;
|
|
165
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
166
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
167
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
168
|
+
readonly rule_id: z.ZodString;
|
|
169
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
170
|
+
readonly message: z.ZodString;
|
|
171
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
172
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
173
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
174
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
175
|
+
level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
176
|
+
policy_sha256: z.ZodString;
|
|
177
|
+
input_sha256: z.ZodString;
|
|
178
|
+
decided_at: z.ZodString;
|
|
179
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
180
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
181
|
+
readonly rule_id: z.ZodString;
|
|
182
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
183
|
+
readonly message: z.ZodString;
|
|
184
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
185
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
186
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
187
|
+
readonly rule_id: z.ZodString;
|
|
188
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
189
|
+
readonly message: z.ZodString;
|
|
190
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
191
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
192
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
193
|
+
readonly rule_id: z.ZodString;
|
|
194
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
195
|
+
readonly message: z.ZodString;
|
|
196
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
197
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
198
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
199
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
200
|
+
level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
201
|
+
policy_sha256: z.ZodString;
|
|
202
|
+
input_sha256: z.ZodString;
|
|
203
|
+
decided_at: z.ZodString;
|
|
204
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
205
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
206
|
+
readonly rule_id: z.ZodString;
|
|
207
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
208
|
+
readonly message: z.ZodString;
|
|
209
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
210
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
211
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
212
|
+
readonly rule_id: z.ZodString;
|
|
213
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
214
|
+
readonly message: z.ZodString;
|
|
215
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
216
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
217
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
218
|
+
readonly rule_id: z.ZodString;
|
|
219
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
220
|
+
readonly message: z.ZodString;
|
|
221
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
222
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
223
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
224
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
225
|
+
level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
226
|
+
policy_sha256: z.ZodString;
|
|
227
|
+
input_sha256: z.ZodString;
|
|
228
|
+
decided_at: z.ZodString;
|
|
229
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
230
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
231
|
+
readonly rule_id: z.ZodString;
|
|
232
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
233
|
+
readonly message: z.ZodString;
|
|
234
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
235
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
236
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
237
|
+
readonly rule_id: z.ZodString;
|
|
238
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
239
|
+
readonly message: z.ZodString;
|
|
240
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
241
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
242
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
243
|
+
readonly rule_id: z.ZodString;
|
|
244
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
245
|
+
readonly message: z.ZodString;
|
|
246
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
247
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
248
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
249
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
250
|
+
level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
251
|
+
policy_sha256: z.ZodString;
|
|
252
|
+
input_sha256: z.ZodString;
|
|
253
|
+
decided_at: z.ZodString;
|
|
254
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
255
|
+
export declare const AutonomyRunState: z.ZodEnum<["queued", "classifying", "awaiting_approval", "blocked", "preparing", "building", "verifying", "repairing", "reviewing", "post_classifying", "candidate_proof", "committing", "pushing", "opening_pr", "waiting_ci", "merging", "deploying_staging", "verifying_staging", "deploying_production", "health_checking", "rolling_back", "deploy_frozen", "final_proof", "blocked_delivery", "delivery_evidence_failed", "escalated", "cancelled", "completed"]>;
|
|
256
|
+
export type AutonomyRunState = z.infer<typeof AutonomyRunState>;
|
|
257
|
+
export declare const AutonomyApprovalPhase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
258
|
+
export type AutonomyApprovalPhase = z.infer<typeof AutonomyApprovalPhase>;
|
|
259
|
+
export declare const ScopedApprovalRequest: z.ZodEffects<z.ZodObject<{
|
|
260
|
+
readonly approval_id: z.ZodString;
|
|
261
|
+
readonly autonomy_run_id: z.ZodString;
|
|
262
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
263
|
+
readonly contract_sha256: z.ZodString;
|
|
264
|
+
readonly diff_sha256: z.ZodString;
|
|
265
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
266
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
267
|
+
readonly nonce: z.ZodString;
|
|
268
|
+
readonly requested_at: z.ZodString;
|
|
269
|
+
readonly expires_at: z.ZodString;
|
|
270
|
+
readonly request_sha256: z.ZodString;
|
|
271
|
+
}, "strict", z.ZodTypeAny, {
|
|
272
|
+
approval_id: string;
|
|
273
|
+
risk: "R3";
|
|
274
|
+
requested_at: string;
|
|
275
|
+
phase: "preflight" | "post_diff";
|
|
276
|
+
diff_sha256: string;
|
|
277
|
+
action_scope: string[];
|
|
278
|
+
expires_at: string;
|
|
279
|
+
autonomy_run_id: string;
|
|
280
|
+
contract_sha256: string;
|
|
281
|
+
nonce: string;
|
|
282
|
+
request_sha256: string;
|
|
283
|
+
}, {
|
|
284
|
+
approval_id: string;
|
|
285
|
+
risk: "R3";
|
|
286
|
+
requested_at: string;
|
|
287
|
+
phase: "preflight" | "post_diff";
|
|
288
|
+
diff_sha256: string;
|
|
289
|
+
action_scope: string[];
|
|
290
|
+
expires_at: string;
|
|
291
|
+
autonomy_run_id: string;
|
|
292
|
+
contract_sha256: string;
|
|
293
|
+
nonce: string;
|
|
294
|
+
request_sha256: string;
|
|
295
|
+
}>, {
|
|
296
|
+
approval_id: string;
|
|
297
|
+
risk: "R3";
|
|
298
|
+
requested_at: string;
|
|
299
|
+
phase: "preflight" | "post_diff";
|
|
300
|
+
diff_sha256: string;
|
|
301
|
+
action_scope: string[];
|
|
302
|
+
expires_at: string;
|
|
303
|
+
autonomy_run_id: string;
|
|
304
|
+
contract_sha256: string;
|
|
305
|
+
nonce: string;
|
|
306
|
+
request_sha256: string;
|
|
307
|
+
}, {
|
|
308
|
+
approval_id: string;
|
|
309
|
+
risk: "R3";
|
|
310
|
+
requested_at: string;
|
|
311
|
+
phase: "preflight" | "post_diff";
|
|
312
|
+
diff_sha256: string;
|
|
313
|
+
action_scope: string[];
|
|
314
|
+
expires_at: string;
|
|
315
|
+
autonomy_run_id: string;
|
|
316
|
+
contract_sha256: string;
|
|
317
|
+
nonce: string;
|
|
318
|
+
request_sha256: string;
|
|
319
|
+
}>;
|
|
320
|
+
export type ScopedApprovalRequest = z.infer<typeof ScopedApprovalRequest>;
|
|
321
|
+
export declare const ScopedApprovalRequestLenient: z.ZodEffects<z.ZodObject<{
|
|
322
|
+
readonly approval_id: z.ZodString;
|
|
323
|
+
readonly autonomy_run_id: z.ZodString;
|
|
324
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
325
|
+
readonly contract_sha256: z.ZodString;
|
|
326
|
+
readonly diff_sha256: z.ZodString;
|
|
327
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
328
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
329
|
+
readonly nonce: z.ZodString;
|
|
330
|
+
readonly requested_at: z.ZodString;
|
|
331
|
+
readonly expires_at: z.ZodString;
|
|
332
|
+
readonly request_sha256: z.ZodString;
|
|
333
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
334
|
+
readonly approval_id: z.ZodString;
|
|
335
|
+
readonly autonomy_run_id: z.ZodString;
|
|
336
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
337
|
+
readonly contract_sha256: z.ZodString;
|
|
338
|
+
readonly diff_sha256: z.ZodString;
|
|
339
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
340
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
341
|
+
readonly nonce: z.ZodString;
|
|
342
|
+
readonly requested_at: z.ZodString;
|
|
343
|
+
readonly expires_at: z.ZodString;
|
|
344
|
+
readonly request_sha256: z.ZodString;
|
|
345
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
346
|
+
readonly approval_id: z.ZodString;
|
|
347
|
+
readonly autonomy_run_id: z.ZodString;
|
|
348
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
349
|
+
readonly contract_sha256: z.ZodString;
|
|
350
|
+
readonly diff_sha256: z.ZodString;
|
|
351
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
352
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
353
|
+
readonly nonce: z.ZodString;
|
|
354
|
+
readonly requested_at: z.ZodString;
|
|
355
|
+
readonly expires_at: z.ZodString;
|
|
356
|
+
readonly request_sha256: z.ZodString;
|
|
357
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
358
|
+
readonly approval_id: z.ZodString;
|
|
359
|
+
readonly autonomy_run_id: z.ZodString;
|
|
360
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
361
|
+
readonly contract_sha256: z.ZodString;
|
|
362
|
+
readonly diff_sha256: z.ZodString;
|
|
363
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
364
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
365
|
+
readonly nonce: z.ZodString;
|
|
366
|
+
readonly requested_at: z.ZodString;
|
|
367
|
+
readonly expires_at: z.ZodString;
|
|
368
|
+
readonly request_sha256: z.ZodString;
|
|
369
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
370
|
+
readonly approval_id: z.ZodString;
|
|
371
|
+
readonly autonomy_run_id: z.ZodString;
|
|
372
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
373
|
+
readonly contract_sha256: z.ZodString;
|
|
374
|
+
readonly diff_sha256: z.ZodString;
|
|
375
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
376
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
377
|
+
readonly nonce: z.ZodString;
|
|
378
|
+
readonly requested_at: z.ZodString;
|
|
379
|
+
readonly expires_at: z.ZodString;
|
|
380
|
+
readonly request_sha256: z.ZodString;
|
|
381
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
382
|
+
export declare const ScopedApprovalDecisionValue: z.ZodEnum<["approve", "reject"]>;
|
|
383
|
+
export type ScopedApprovalDecisionValue = z.infer<typeof ScopedApprovalDecisionValue>;
|
|
384
|
+
export declare const ScopedApprovalDecisionPayload: z.ZodEffects<z.ZodObject<{
|
|
385
|
+
readonly approval_id: z.ZodString;
|
|
386
|
+
readonly request_sha256: z.ZodString;
|
|
387
|
+
readonly autonomy_run_id: z.ZodString;
|
|
388
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
389
|
+
readonly contract_sha256: z.ZodString;
|
|
390
|
+
readonly diff_sha256: z.ZodString;
|
|
391
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
392
|
+
readonly decision: z.ZodEnum<["approve", "reject"]>;
|
|
393
|
+
readonly nonce: z.ZodString;
|
|
394
|
+
readonly issued_at: z.ZodString;
|
|
395
|
+
readonly expires_at: z.ZodString;
|
|
396
|
+
readonly decided_by: z.ZodEffects<z.ZodObject<{
|
|
397
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
398
|
+
readonly id: z.ZodString;
|
|
399
|
+
}, "strict", z.ZodTypeAny, {
|
|
400
|
+
type: "human" | "agent";
|
|
401
|
+
id: string;
|
|
402
|
+
}, {
|
|
403
|
+
type: "human" | "agent";
|
|
404
|
+
id: string;
|
|
405
|
+
}>, {
|
|
406
|
+
type: "human" | "agent";
|
|
407
|
+
id: string;
|
|
408
|
+
}, {
|
|
409
|
+
type: "human" | "agent";
|
|
410
|
+
id: string;
|
|
411
|
+
}>;
|
|
412
|
+
}, "strict", z.ZodTypeAny, {
|
|
413
|
+
approval_id: string;
|
|
414
|
+
decided_by: {
|
|
415
|
+
type: "human" | "agent";
|
|
416
|
+
id: string;
|
|
417
|
+
};
|
|
418
|
+
phase: "preflight" | "post_diff";
|
|
419
|
+
diff_sha256: string;
|
|
420
|
+
action_scope: string[];
|
|
421
|
+
expires_at: string;
|
|
422
|
+
autonomy_run_id: string;
|
|
423
|
+
contract_sha256: string;
|
|
424
|
+
nonce: string;
|
|
425
|
+
request_sha256: string;
|
|
426
|
+
decision: "approve" | "reject";
|
|
427
|
+
issued_at: string;
|
|
428
|
+
}, {
|
|
429
|
+
approval_id: string;
|
|
430
|
+
decided_by: {
|
|
431
|
+
type: "human" | "agent";
|
|
432
|
+
id: string;
|
|
433
|
+
};
|
|
434
|
+
phase: "preflight" | "post_diff";
|
|
435
|
+
diff_sha256: string;
|
|
436
|
+
action_scope: string[];
|
|
437
|
+
expires_at: string;
|
|
438
|
+
autonomy_run_id: string;
|
|
439
|
+
contract_sha256: string;
|
|
440
|
+
nonce: string;
|
|
441
|
+
request_sha256: string;
|
|
442
|
+
decision: "approve" | "reject";
|
|
443
|
+
issued_at: string;
|
|
444
|
+
}>, {
|
|
445
|
+
approval_id: string;
|
|
446
|
+
decided_by: {
|
|
447
|
+
type: "human" | "agent";
|
|
448
|
+
id: string;
|
|
449
|
+
};
|
|
450
|
+
phase: "preflight" | "post_diff";
|
|
451
|
+
diff_sha256: string;
|
|
452
|
+
action_scope: string[];
|
|
453
|
+
expires_at: string;
|
|
454
|
+
autonomy_run_id: string;
|
|
455
|
+
contract_sha256: string;
|
|
456
|
+
nonce: string;
|
|
457
|
+
request_sha256: string;
|
|
458
|
+
decision: "approve" | "reject";
|
|
459
|
+
issued_at: string;
|
|
460
|
+
}, {
|
|
461
|
+
approval_id: string;
|
|
462
|
+
decided_by: {
|
|
463
|
+
type: "human" | "agent";
|
|
464
|
+
id: string;
|
|
465
|
+
};
|
|
466
|
+
phase: "preflight" | "post_diff";
|
|
467
|
+
diff_sha256: string;
|
|
468
|
+
action_scope: string[];
|
|
469
|
+
expires_at: string;
|
|
470
|
+
autonomy_run_id: string;
|
|
471
|
+
contract_sha256: string;
|
|
472
|
+
nonce: string;
|
|
473
|
+
request_sha256: string;
|
|
474
|
+
decision: "approve" | "reject";
|
|
475
|
+
issued_at: string;
|
|
476
|
+
}>;
|
|
477
|
+
export type ScopedApprovalDecisionPayload = z.infer<typeof ScopedApprovalDecisionPayload>;
|
|
478
|
+
export declare const ScopedApprovalDecision: z.ZodObject<{
|
|
479
|
+
payload: z.ZodEffects<z.ZodObject<{
|
|
480
|
+
readonly approval_id: z.ZodString;
|
|
481
|
+
readonly request_sha256: z.ZodString;
|
|
482
|
+
readonly autonomy_run_id: z.ZodString;
|
|
483
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
484
|
+
readonly contract_sha256: z.ZodString;
|
|
485
|
+
readonly diff_sha256: z.ZodString;
|
|
486
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
487
|
+
readonly decision: z.ZodEnum<["approve", "reject"]>;
|
|
488
|
+
readonly nonce: z.ZodString;
|
|
489
|
+
readonly issued_at: z.ZodString;
|
|
490
|
+
readonly expires_at: z.ZodString;
|
|
491
|
+
readonly decided_by: z.ZodEffects<z.ZodObject<{
|
|
492
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
493
|
+
readonly id: z.ZodString;
|
|
494
|
+
}, "strict", z.ZodTypeAny, {
|
|
495
|
+
type: "human" | "agent";
|
|
496
|
+
id: string;
|
|
497
|
+
}, {
|
|
498
|
+
type: "human" | "agent";
|
|
499
|
+
id: string;
|
|
500
|
+
}>, {
|
|
501
|
+
type: "human" | "agent";
|
|
502
|
+
id: string;
|
|
503
|
+
}, {
|
|
504
|
+
type: "human" | "agent";
|
|
505
|
+
id: string;
|
|
506
|
+
}>;
|
|
507
|
+
}, "strict", z.ZodTypeAny, {
|
|
508
|
+
approval_id: string;
|
|
509
|
+
decided_by: {
|
|
510
|
+
type: "human" | "agent";
|
|
511
|
+
id: string;
|
|
512
|
+
};
|
|
513
|
+
phase: "preflight" | "post_diff";
|
|
514
|
+
diff_sha256: string;
|
|
515
|
+
action_scope: string[];
|
|
516
|
+
expires_at: string;
|
|
517
|
+
autonomy_run_id: string;
|
|
518
|
+
contract_sha256: string;
|
|
519
|
+
nonce: string;
|
|
520
|
+
request_sha256: string;
|
|
521
|
+
decision: "approve" | "reject";
|
|
522
|
+
issued_at: string;
|
|
523
|
+
}, {
|
|
524
|
+
approval_id: string;
|
|
525
|
+
decided_by: {
|
|
526
|
+
type: "human" | "agent";
|
|
527
|
+
id: string;
|
|
528
|
+
};
|
|
529
|
+
phase: "preflight" | "post_diff";
|
|
530
|
+
diff_sha256: string;
|
|
531
|
+
action_scope: string[];
|
|
532
|
+
expires_at: string;
|
|
533
|
+
autonomy_run_id: string;
|
|
534
|
+
contract_sha256: string;
|
|
535
|
+
nonce: string;
|
|
536
|
+
request_sha256: string;
|
|
537
|
+
decision: "approve" | "reject";
|
|
538
|
+
issued_at: string;
|
|
539
|
+
}>, {
|
|
540
|
+
approval_id: string;
|
|
541
|
+
decided_by: {
|
|
542
|
+
type: "human" | "agent";
|
|
543
|
+
id: string;
|
|
544
|
+
};
|
|
545
|
+
phase: "preflight" | "post_diff";
|
|
546
|
+
diff_sha256: string;
|
|
547
|
+
action_scope: string[];
|
|
548
|
+
expires_at: string;
|
|
549
|
+
autonomy_run_id: string;
|
|
550
|
+
contract_sha256: string;
|
|
551
|
+
nonce: string;
|
|
552
|
+
request_sha256: string;
|
|
553
|
+
decision: "approve" | "reject";
|
|
554
|
+
issued_at: string;
|
|
555
|
+
}, {
|
|
556
|
+
approval_id: string;
|
|
557
|
+
decided_by: {
|
|
558
|
+
type: "human" | "agent";
|
|
559
|
+
id: string;
|
|
560
|
+
};
|
|
561
|
+
phase: "preflight" | "post_diff";
|
|
562
|
+
diff_sha256: string;
|
|
563
|
+
action_scope: string[];
|
|
564
|
+
expires_at: string;
|
|
565
|
+
autonomy_run_id: string;
|
|
566
|
+
contract_sha256: string;
|
|
567
|
+
nonce: string;
|
|
568
|
+
request_sha256: string;
|
|
569
|
+
decision: "approve" | "reject";
|
|
570
|
+
issued_at: string;
|
|
571
|
+
}>;
|
|
572
|
+
signature: z.ZodObject<{
|
|
573
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
574
|
+
readonly key_id: z.ZodString;
|
|
575
|
+
readonly value_base64url: z.ZodString;
|
|
576
|
+
}, "strict", z.ZodTypeAny, {
|
|
577
|
+
algorithm: "Ed25519";
|
|
578
|
+
key_id: string;
|
|
579
|
+
value_base64url: string;
|
|
580
|
+
}, {
|
|
581
|
+
algorithm: "Ed25519";
|
|
582
|
+
key_id: string;
|
|
583
|
+
value_base64url: string;
|
|
584
|
+
}>;
|
|
585
|
+
}, "strict", z.ZodTypeAny, {
|
|
586
|
+
payload: {
|
|
587
|
+
approval_id: string;
|
|
588
|
+
decided_by: {
|
|
589
|
+
type: "human" | "agent";
|
|
590
|
+
id: string;
|
|
591
|
+
};
|
|
592
|
+
phase: "preflight" | "post_diff";
|
|
593
|
+
diff_sha256: string;
|
|
594
|
+
action_scope: string[];
|
|
595
|
+
expires_at: string;
|
|
596
|
+
autonomy_run_id: string;
|
|
597
|
+
contract_sha256: string;
|
|
598
|
+
nonce: string;
|
|
599
|
+
request_sha256: string;
|
|
600
|
+
decision: "approve" | "reject";
|
|
601
|
+
issued_at: string;
|
|
602
|
+
};
|
|
603
|
+
signature: {
|
|
604
|
+
algorithm: "Ed25519";
|
|
605
|
+
key_id: string;
|
|
606
|
+
value_base64url: string;
|
|
607
|
+
};
|
|
608
|
+
}, {
|
|
609
|
+
payload: {
|
|
610
|
+
approval_id: string;
|
|
611
|
+
decided_by: {
|
|
612
|
+
type: "human" | "agent";
|
|
613
|
+
id: string;
|
|
614
|
+
};
|
|
615
|
+
phase: "preflight" | "post_diff";
|
|
616
|
+
diff_sha256: string;
|
|
617
|
+
action_scope: string[];
|
|
618
|
+
expires_at: string;
|
|
619
|
+
autonomy_run_id: string;
|
|
620
|
+
contract_sha256: string;
|
|
621
|
+
nonce: string;
|
|
622
|
+
request_sha256: string;
|
|
623
|
+
decision: "approve" | "reject";
|
|
624
|
+
issued_at: string;
|
|
625
|
+
};
|
|
626
|
+
signature: {
|
|
627
|
+
algorithm: "Ed25519";
|
|
628
|
+
key_id: string;
|
|
629
|
+
value_base64url: string;
|
|
630
|
+
};
|
|
631
|
+
}>;
|
|
632
|
+
export type ScopedApprovalDecision = z.infer<typeof ScopedApprovalDecision>;
|
|
633
|
+
export declare const ScopedApprovalDecisionLenient: z.ZodObject<{
|
|
634
|
+
payload: z.ZodEffects<z.ZodObject<{
|
|
635
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
636
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
637
|
+
readonly id: z.ZodString;
|
|
638
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
639
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
640
|
+
readonly id: z.ZodString;
|
|
641
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
642
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
643
|
+
readonly id: z.ZodString;
|
|
644
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
645
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
646
|
+
readonly id: z.ZodString;
|
|
647
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
648
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
649
|
+
readonly id: z.ZodString;
|
|
650
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
651
|
+
approval_id: z.ZodString;
|
|
652
|
+
request_sha256: z.ZodString;
|
|
653
|
+
autonomy_run_id: z.ZodString;
|
|
654
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
655
|
+
contract_sha256: z.ZodString;
|
|
656
|
+
diff_sha256: z.ZodString;
|
|
657
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
658
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
659
|
+
nonce: z.ZodString;
|
|
660
|
+
issued_at: z.ZodString;
|
|
661
|
+
expires_at: z.ZodString;
|
|
662
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
663
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
664
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
665
|
+
readonly id: z.ZodString;
|
|
666
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
667
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
668
|
+
readonly id: z.ZodString;
|
|
669
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
670
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
671
|
+
readonly id: z.ZodString;
|
|
672
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
673
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
674
|
+
readonly id: z.ZodString;
|
|
675
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
676
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
677
|
+
readonly id: z.ZodString;
|
|
678
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
679
|
+
approval_id: z.ZodString;
|
|
680
|
+
request_sha256: z.ZodString;
|
|
681
|
+
autonomy_run_id: z.ZodString;
|
|
682
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
683
|
+
contract_sha256: z.ZodString;
|
|
684
|
+
diff_sha256: z.ZodString;
|
|
685
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
686
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
687
|
+
nonce: z.ZodString;
|
|
688
|
+
issued_at: z.ZodString;
|
|
689
|
+
expires_at: z.ZodString;
|
|
690
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
691
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
692
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
693
|
+
readonly id: z.ZodString;
|
|
694
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
695
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
696
|
+
readonly id: z.ZodString;
|
|
697
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
698
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
699
|
+
readonly id: z.ZodString;
|
|
700
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
701
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
702
|
+
readonly id: z.ZodString;
|
|
703
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
704
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
705
|
+
readonly id: z.ZodString;
|
|
706
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
707
|
+
approval_id: z.ZodString;
|
|
708
|
+
request_sha256: z.ZodString;
|
|
709
|
+
autonomy_run_id: z.ZodString;
|
|
710
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
711
|
+
contract_sha256: z.ZodString;
|
|
712
|
+
diff_sha256: z.ZodString;
|
|
713
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
714
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
715
|
+
nonce: z.ZodString;
|
|
716
|
+
issued_at: z.ZodString;
|
|
717
|
+
expires_at: z.ZodString;
|
|
718
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
719
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
720
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
721
|
+
readonly id: z.ZodString;
|
|
722
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
723
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
724
|
+
readonly id: z.ZodString;
|
|
725
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
726
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
727
|
+
readonly id: z.ZodString;
|
|
728
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
729
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
730
|
+
readonly id: z.ZodString;
|
|
731
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
732
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
733
|
+
readonly id: z.ZodString;
|
|
734
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
735
|
+
approval_id: z.ZodString;
|
|
736
|
+
request_sha256: z.ZodString;
|
|
737
|
+
autonomy_run_id: z.ZodString;
|
|
738
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
739
|
+
contract_sha256: z.ZodString;
|
|
740
|
+
diff_sha256: z.ZodString;
|
|
741
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
742
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
743
|
+
nonce: z.ZodString;
|
|
744
|
+
issued_at: z.ZodString;
|
|
745
|
+
expires_at: z.ZodString;
|
|
746
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
747
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
748
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
749
|
+
readonly id: z.ZodString;
|
|
750
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
751
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
752
|
+
readonly id: z.ZodString;
|
|
753
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
754
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
755
|
+
readonly id: z.ZodString;
|
|
756
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
757
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
758
|
+
readonly id: z.ZodString;
|
|
759
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
760
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
761
|
+
readonly id: z.ZodString;
|
|
762
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
763
|
+
approval_id: z.ZodString;
|
|
764
|
+
request_sha256: z.ZodString;
|
|
765
|
+
autonomy_run_id: z.ZodString;
|
|
766
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
767
|
+
contract_sha256: z.ZodString;
|
|
768
|
+
diff_sha256: z.ZodString;
|
|
769
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
770
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
771
|
+
nonce: z.ZodString;
|
|
772
|
+
issued_at: z.ZodString;
|
|
773
|
+
expires_at: z.ZodString;
|
|
774
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
775
|
+
signature: z.ZodObject<{
|
|
776
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
777
|
+
readonly key_id: z.ZodString;
|
|
778
|
+
readonly value_base64url: z.ZodString;
|
|
779
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
780
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
781
|
+
readonly key_id: z.ZodString;
|
|
782
|
+
readonly value_base64url: z.ZodString;
|
|
783
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
784
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
785
|
+
readonly key_id: z.ZodString;
|
|
786
|
+
readonly value_base64url: z.ZodString;
|
|
787
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
788
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
789
|
+
payload: z.ZodEffects<z.ZodObject<{
|
|
790
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
791
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
792
|
+
readonly id: z.ZodString;
|
|
793
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
794
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
795
|
+
readonly id: z.ZodString;
|
|
796
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
797
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
798
|
+
readonly id: z.ZodString;
|
|
799
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
800
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
801
|
+
readonly id: z.ZodString;
|
|
802
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
803
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
804
|
+
readonly id: z.ZodString;
|
|
805
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
806
|
+
approval_id: z.ZodString;
|
|
807
|
+
request_sha256: z.ZodString;
|
|
808
|
+
autonomy_run_id: z.ZodString;
|
|
809
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
810
|
+
contract_sha256: z.ZodString;
|
|
811
|
+
diff_sha256: z.ZodString;
|
|
812
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
813
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
814
|
+
nonce: z.ZodString;
|
|
815
|
+
issued_at: z.ZodString;
|
|
816
|
+
expires_at: z.ZodString;
|
|
817
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
818
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
819
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
820
|
+
readonly id: z.ZodString;
|
|
821
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
822
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
823
|
+
readonly id: z.ZodString;
|
|
824
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
825
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
826
|
+
readonly id: z.ZodString;
|
|
827
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
828
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
829
|
+
readonly id: z.ZodString;
|
|
830
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
831
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
832
|
+
readonly id: z.ZodString;
|
|
833
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
834
|
+
approval_id: z.ZodString;
|
|
835
|
+
request_sha256: z.ZodString;
|
|
836
|
+
autonomy_run_id: z.ZodString;
|
|
837
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
838
|
+
contract_sha256: z.ZodString;
|
|
839
|
+
diff_sha256: z.ZodString;
|
|
840
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
841
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
842
|
+
nonce: z.ZodString;
|
|
843
|
+
issued_at: z.ZodString;
|
|
844
|
+
expires_at: z.ZodString;
|
|
845
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
846
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
847
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
848
|
+
readonly id: z.ZodString;
|
|
849
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
850
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
851
|
+
readonly id: z.ZodString;
|
|
852
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
853
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
854
|
+
readonly id: z.ZodString;
|
|
855
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
856
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
857
|
+
readonly id: z.ZodString;
|
|
858
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
859
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
860
|
+
readonly id: z.ZodString;
|
|
861
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
862
|
+
approval_id: z.ZodString;
|
|
863
|
+
request_sha256: z.ZodString;
|
|
864
|
+
autonomy_run_id: z.ZodString;
|
|
865
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
866
|
+
contract_sha256: z.ZodString;
|
|
867
|
+
diff_sha256: z.ZodString;
|
|
868
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
869
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
870
|
+
nonce: z.ZodString;
|
|
871
|
+
issued_at: z.ZodString;
|
|
872
|
+
expires_at: z.ZodString;
|
|
873
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
874
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
875
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
876
|
+
readonly id: z.ZodString;
|
|
877
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
878
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
879
|
+
readonly id: z.ZodString;
|
|
880
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
881
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
882
|
+
readonly id: z.ZodString;
|
|
883
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
884
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
885
|
+
readonly id: z.ZodString;
|
|
886
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
887
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
888
|
+
readonly id: z.ZodString;
|
|
889
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
890
|
+
approval_id: z.ZodString;
|
|
891
|
+
request_sha256: z.ZodString;
|
|
892
|
+
autonomy_run_id: z.ZodString;
|
|
893
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
894
|
+
contract_sha256: z.ZodString;
|
|
895
|
+
diff_sha256: z.ZodString;
|
|
896
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
897
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
898
|
+
nonce: z.ZodString;
|
|
899
|
+
issued_at: z.ZodString;
|
|
900
|
+
expires_at: z.ZodString;
|
|
901
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
902
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
903
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
904
|
+
readonly id: z.ZodString;
|
|
905
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
906
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
907
|
+
readonly id: z.ZodString;
|
|
908
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
909
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
910
|
+
readonly id: z.ZodString;
|
|
911
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
912
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
913
|
+
readonly id: z.ZodString;
|
|
914
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
915
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
916
|
+
readonly id: z.ZodString;
|
|
917
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
918
|
+
approval_id: z.ZodString;
|
|
919
|
+
request_sha256: z.ZodString;
|
|
920
|
+
autonomy_run_id: z.ZodString;
|
|
921
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
922
|
+
contract_sha256: z.ZodString;
|
|
923
|
+
diff_sha256: z.ZodString;
|
|
924
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
925
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
926
|
+
nonce: z.ZodString;
|
|
927
|
+
issued_at: z.ZodString;
|
|
928
|
+
expires_at: z.ZodString;
|
|
929
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
930
|
+
signature: z.ZodObject<{
|
|
931
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
932
|
+
readonly key_id: z.ZodString;
|
|
933
|
+
readonly value_base64url: z.ZodString;
|
|
934
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
935
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
936
|
+
readonly key_id: z.ZodString;
|
|
937
|
+
readonly value_base64url: z.ZodString;
|
|
938
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
939
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
940
|
+
readonly key_id: z.ZodString;
|
|
941
|
+
readonly value_base64url: z.ZodString;
|
|
942
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
943
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
944
|
+
payload: z.ZodEffects<z.ZodObject<{
|
|
945
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
946
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
947
|
+
readonly id: z.ZodString;
|
|
948
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
949
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
950
|
+
readonly id: z.ZodString;
|
|
951
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
952
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
953
|
+
readonly id: z.ZodString;
|
|
954
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
955
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
956
|
+
readonly id: z.ZodString;
|
|
957
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
958
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
959
|
+
readonly id: z.ZodString;
|
|
960
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
961
|
+
approval_id: z.ZodString;
|
|
962
|
+
request_sha256: z.ZodString;
|
|
963
|
+
autonomy_run_id: z.ZodString;
|
|
964
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
965
|
+
contract_sha256: z.ZodString;
|
|
966
|
+
diff_sha256: z.ZodString;
|
|
967
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
968
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
969
|
+
nonce: z.ZodString;
|
|
970
|
+
issued_at: z.ZodString;
|
|
971
|
+
expires_at: z.ZodString;
|
|
972
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
973
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
974
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
975
|
+
readonly id: z.ZodString;
|
|
976
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
977
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
978
|
+
readonly id: z.ZodString;
|
|
979
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
980
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
981
|
+
readonly id: z.ZodString;
|
|
982
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
983
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
984
|
+
readonly id: z.ZodString;
|
|
985
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
986
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
987
|
+
readonly id: z.ZodString;
|
|
988
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
989
|
+
approval_id: z.ZodString;
|
|
990
|
+
request_sha256: z.ZodString;
|
|
991
|
+
autonomy_run_id: z.ZodString;
|
|
992
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
993
|
+
contract_sha256: z.ZodString;
|
|
994
|
+
diff_sha256: z.ZodString;
|
|
995
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
996
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
997
|
+
nonce: z.ZodString;
|
|
998
|
+
issued_at: z.ZodString;
|
|
999
|
+
expires_at: z.ZodString;
|
|
1000
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1001
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1002
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1003
|
+
readonly id: z.ZodString;
|
|
1004
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1005
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1006
|
+
readonly id: z.ZodString;
|
|
1007
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1008
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1009
|
+
readonly id: z.ZodString;
|
|
1010
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1011
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1012
|
+
readonly id: z.ZodString;
|
|
1013
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1014
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1015
|
+
readonly id: z.ZodString;
|
|
1016
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1017
|
+
approval_id: z.ZodString;
|
|
1018
|
+
request_sha256: z.ZodString;
|
|
1019
|
+
autonomy_run_id: z.ZodString;
|
|
1020
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1021
|
+
contract_sha256: z.ZodString;
|
|
1022
|
+
diff_sha256: z.ZodString;
|
|
1023
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1024
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1025
|
+
nonce: z.ZodString;
|
|
1026
|
+
issued_at: z.ZodString;
|
|
1027
|
+
expires_at: z.ZodString;
|
|
1028
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1029
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1030
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1031
|
+
readonly id: z.ZodString;
|
|
1032
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1033
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1034
|
+
readonly id: z.ZodString;
|
|
1035
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1036
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1037
|
+
readonly id: z.ZodString;
|
|
1038
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1039
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1040
|
+
readonly id: z.ZodString;
|
|
1041
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1042
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1043
|
+
readonly id: z.ZodString;
|
|
1044
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1045
|
+
approval_id: z.ZodString;
|
|
1046
|
+
request_sha256: z.ZodString;
|
|
1047
|
+
autonomy_run_id: z.ZodString;
|
|
1048
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1049
|
+
contract_sha256: z.ZodString;
|
|
1050
|
+
diff_sha256: z.ZodString;
|
|
1051
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1052
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1053
|
+
nonce: z.ZodString;
|
|
1054
|
+
issued_at: z.ZodString;
|
|
1055
|
+
expires_at: z.ZodString;
|
|
1056
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1057
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1058
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1059
|
+
readonly id: z.ZodString;
|
|
1060
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1061
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1062
|
+
readonly id: z.ZodString;
|
|
1063
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1064
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1065
|
+
readonly id: z.ZodString;
|
|
1066
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1067
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1068
|
+
readonly id: z.ZodString;
|
|
1069
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1070
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1071
|
+
readonly id: z.ZodString;
|
|
1072
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1073
|
+
approval_id: z.ZodString;
|
|
1074
|
+
request_sha256: z.ZodString;
|
|
1075
|
+
autonomy_run_id: z.ZodString;
|
|
1076
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1077
|
+
contract_sha256: z.ZodString;
|
|
1078
|
+
diff_sha256: z.ZodString;
|
|
1079
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1080
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1081
|
+
nonce: z.ZodString;
|
|
1082
|
+
issued_at: z.ZodString;
|
|
1083
|
+
expires_at: z.ZodString;
|
|
1084
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1085
|
+
signature: z.ZodObject<{
|
|
1086
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
1087
|
+
readonly key_id: z.ZodString;
|
|
1088
|
+
readonly value_base64url: z.ZodString;
|
|
1089
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1090
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
1091
|
+
readonly key_id: z.ZodString;
|
|
1092
|
+
readonly value_base64url: z.ZodString;
|
|
1093
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1094
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
1095
|
+
readonly key_id: z.ZodString;
|
|
1096
|
+
readonly value_base64url: z.ZodString;
|
|
1097
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1098
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1099
|
+
export declare function parseInboundAutonomyRiskDecision(input: unknown): z.objectOutputType<{
|
|
1100
|
+
signals: z.ZodArray<z.ZodObject<{
|
|
1101
|
+
readonly rule_id: z.ZodString;
|
|
1102
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
1103
|
+
readonly message: z.ZodString;
|
|
1104
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
1105
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
1106
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1107
|
+
readonly rule_id: z.ZodString;
|
|
1108
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
1109
|
+
readonly message: z.ZodString;
|
|
1110
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
1111
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
1112
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1113
|
+
readonly rule_id: z.ZodString;
|
|
1114
|
+
readonly level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
1115
|
+
readonly message: z.ZodString;
|
|
1116
|
+
readonly path: z.ZodOptional<z.ZodString>;
|
|
1117
|
+
readonly command: z.ZodOptional<z.ZodString>;
|
|
1118
|
+
}, z.ZodTypeAny, "passthrough">>, "many">;
|
|
1119
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1120
|
+
level: z.ZodEnum<["R0", "R1", "R2", "R3", "R4"]>;
|
|
1121
|
+
policy_sha256: z.ZodString;
|
|
1122
|
+
input_sha256: z.ZodString;
|
|
1123
|
+
decided_at: z.ZodString;
|
|
1124
|
+
}, z.ZodTypeAny, "passthrough">;
|
|
1125
|
+
export declare function parseInboundScopedApprovalRequest(input: unknown): z.objectOutputType<{
|
|
1126
|
+
readonly approval_id: z.ZodString;
|
|
1127
|
+
readonly autonomy_run_id: z.ZodString;
|
|
1128
|
+
readonly phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1129
|
+
readonly contract_sha256: z.ZodString;
|
|
1130
|
+
readonly diff_sha256: z.ZodString;
|
|
1131
|
+
readonly action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1132
|
+
readonly risk: z.ZodLiteral<"R3">;
|
|
1133
|
+
readonly nonce: z.ZodString;
|
|
1134
|
+
readonly requested_at: z.ZodString;
|
|
1135
|
+
readonly expires_at: z.ZodString;
|
|
1136
|
+
readonly request_sha256: z.ZodString;
|
|
1137
|
+
}, z.ZodTypeAny, "passthrough">;
|
|
1138
|
+
export declare function parseInboundScopedApprovalDecision(input: unknown): z.objectOutputType<{
|
|
1139
|
+
payload: z.ZodEffects<z.ZodObject<{
|
|
1140
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1141
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1142
|
+
readonly id: z.ZodString;
|
|
1143
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1144
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1145
|
+
readonly id: z.ZodString;
|
|
1146
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1147
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1148
|
+
readonly id: z.ZodString;
|
|
1149
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1150
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1151
|
+
readonly id: z.ZodString;
|
|
1152
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1153
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1154
|
+
readonly id: z.ZodString;
|
|
1155
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1156
|
+
approval_id: z.ZodString;
|
|
1157
|
+
request_sha256: z.ZodString;
|
|
1158
|
+
autonomy_run_id: z.ZodString;
|
|
1159
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1160
|
+
contract_sha256: z.ZodString;
|
|
1161
|
+
diff_sha256: z.ZodString;
|
|
1162
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1163
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1164
|
+
nonce: z.ZodString;
|
|
1165
|
+
issued_at: z.ZodString;
|
|
1166
|
+
expires_at: z.ZodString;
|
|
1167
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1168
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1169
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1170
|
+
readonly id: z.ZodString;
|
|
1171
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1172
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1173
|
+
readonly id: z.ZodString;
|
|
1174
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1175
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1176
|
+
readonly id: z.ZodString;
|
|
1177
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1178
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1179
|
+
readonly id: z.ZodString;
|
|
1180
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1181
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1182
|
+
readonly id: z.ZodString;
|
|
1183
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1184
|
+
approval_id: z.ZodString;
|
|
1185
|
+
request_sha256: z.ZodString;
|
|
1186
|
+
autonomy_run_id: z.ZodString;
|
|
1187
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1188
|
+
contract_sha256: z.ZodString;
|
|
1189
|
+
diff_sha256: z.ZodString;
|
|
1190
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1191
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1192
|
+
nonce: z.ZodString;
|
|
1193
|
+
issued_at: z.ZodString;
|
|
1194
|
+
expires_at: z.ZodString;
|
|
1195
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1196
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1197
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1198
|
+
readonly id: z.ZodString;
|
|
1199
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1200
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1201
|
+
readonly id: z.ZodString;
|
|
1202
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1203
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1204
|
+
readonly id: z.ZodString;
|
|
1205
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1206
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1207
|
+
readonly id: z.ZodString;
|
|
1208
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1209
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1210
|
+
readonly id: z.ZodString;
|
|
1211
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1212
|
+
approval_id: z.ZodString;
|
|
1213
|
+
request_sha256: z.ZodString;
|
|
1214
|
+
autonomy_run_id: z.ZodString;
|
|
1215
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1216
|
+
contract_sha256: z.ZodString;
|
|
1217
|
+
diff_sha256: z.ZodString;
|
|
1218
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1219
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1220
|
+
nonce: z.ZodString;
|
|
1221
|
+
issued_at: z.ZodString;
|
|
1222
|
+
expires_at: z.ZodString;
|
|
1223
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1224
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1225
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1226
|
+
readonly id: z.ZodString;
|
|
1227
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1228
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1229
|
+
readonly id: z.ZodString;
|
|
1230
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1231
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1232
|
+
readonly id: z.ZodString;
|
|
1233
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1234
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1235
|
+
readonly id: z.ZodString;
|
|
1236
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1237
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1238
|
+
readonly id: z.ZodString;
|
|
1239
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1240
|
+
approval_id: z.ZodString;
|
|
1241
|
+
request_sha256: z.ZodString;
|
|
1242
|
+
autonomy_run_id: z.ZodString;
|
|
1243
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1244
|
+
contract_sha256: z.ZodString;
|
|
1245
|
+
diff_sha256: z.ZodString;
|
|
1246
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1247
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1248
|
+
nonce: z.ZodString;
|
|
1249
|
+
issued_at: z.ZodString;
|
|
1250
|
+
expires_at: z.ZodString;
|
|
1251
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1252
|
+
decided_by: z.ZodEffects<z.ZodObject<{
|
|
1253
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1254
|
+
readonly id: z.ZodString;
|
|
1255
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1256
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1257
|
+
readonly id: z.ZodString;
|
|
1258
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1259
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1260
|
+
readonly id: z.ZodString;
|
|
1261
|
+
}, z.ZodTypeAny, "passthrough">>, z.objectOutputType<{
|
|
1262
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1263
|
+
readonly id: z.ZodString;
|
|
1264
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1265
|
+
readonly type: z.ZodEnum<["human", "agent"]>;
|
|
1266
|
+
readonly id: z.ZodString;
|
|
1267
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1268
|
+
approval_id: z.ZodString;
|
|
1269
|
+
request_sha256: z.ZodString;
|
|
1270
|
+
autonomy_run_id: z.ZodString;
|
|
1271
|
+
phase: z.ZodEnum<["preflight", "post_diff"]>;
|
|
1272
|
+
contract_sha256: z.ZodString;
|
|
1273
|
+
diff_sha256: z.ZodString;
|
|
1274
|
+
action_scope: z.ZodEffects<z.ZodArray<z.ZodString, "many">, string[], string[]>;
|
|
1275
|
+
decision: z.ZodEnum<["approve", "reject"]>;
|
|
1276
|
+
nonce: z.ZodString;
|
|
1277
|
+
issued_at: z.ZodString;
|
|
1278
|
+
expires_at: z.ZodString;
|
|
1279
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1280
|
+
signature: z.ZodObject<{
|
|
1281
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
1282
|
+
readonly key_id: z.ZodString;
|
|
1283
|
+
readonly value_base64url: z.ZodString;
|
|
1284
|
+
}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
|
|
1285
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
1286
|
+
readonly key_id: z.ZodString;
|
|
1287
|
+
readonly value_base64url: z.ZodString;
|
|
1288
|
+
}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
|
|
1289
|
+
readonly algorithm: z.ZodLiteral<"Ed25519">;
|
|
1290
|
+
readonly key_id: z.ZodString;
|
|
1291
|
+
readonly value_base64url: z.ZodString;
|
|
1292
|
+
}, z.ZodTypeAny, "passthrough">>;
|
|
1293
|
+
}, z.ZodTypeAny, "passthrough">;
|
|
1294
|
+
/**
|
|
1295
|
+
* Validates structural and request-binding invariants. Cryptographic signature,
|
|
1296
|
+
* nonce replay, trusted-key, and wall-clock expiry checks belong to the
|
|
1297
|
+
* autonomy verifier, which owns those runtime dependencies.
|
|
1298
|
+
*/
|
|
1299
|
+
export declare function validateScopedApprovalDecisionForRequest(requestInput: unknown, decisionInput: unknown): ScopedApprovalDecision;
|
|
1300
|
+
//# sourceMappingURL=autonomy.d.ts.map
|