@adea-ai/contracts 1.11.0 → 1.11.1

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.
@@ -1,10 +1,10 @@
1
1
  import { z } from 'zod';
2
2
  export declare const ServiceScopeSchema: z.ZodString;
3
3
  export declare const ServiceCredentialKindSchema: z.ZodEnum<{
4
- service: "service";
5
4
  browser_session: "browser_session";
6
- runtime_device: "runtime_device";
7
5
  provider: "provider";
6
+ runtime_device: "runtime_device";
7
+ service: "service";
8
8
  }>;
9
9
  export type ServiceCredentialKind = z.infer<typeof ServiceCredentialKindSchema>;
10
10
  export declare const ServiceCallerAssertionSchema: z.ZodObject<{
@@ -15,10 +15,10 @@ export declare const ServiceCredentialClaimsSchema: z.ZodObject<{
15
15
  audience: z.ZodString;
16
16
  credentialId: z.ZodString;
17
17
  credentialKind: z.ZodEnum<{
18
- service: "service";
19
18
  browser_session: "browser_session";
20
- runtime_device: "runtime_device";
21
19
  provider: "provider";
20
+ runtime_device: "runtime_device";
21
+ service: "service";
22
22
  }>;
23
23
  expiresAt: z.ZodISODateTime;
24
24
  issuedAt: z.ZodISODateTime;
@@ -13,14 +13,14 @@ export declare const ContextProviderDefinitionSchema: z.ZodObject<{
13
13
  displayName: z.ZodString;
14
14
  contractVersion: z.ZodString;
15
15
  latencyClass: z.ZodDefault<z.ZodEnum<{
16
+ high: "high";
16
17
  low: "low";
17
18
  standard: "standard";
18
- high: "high";
19
19
  }>>;
20
20
  costClass: z.ZodDefault<z.ZodEnum<{
21
21
  low: "low";
22
- standard: "standard";
23
22
  premium: "premium";
23
+ standard: "standard";
24
24
  }>>;
25
25
  capabilities: z.ZodObject<{
26
26
  boundedRetrieval: z.ZodBoolean;
@@ -65,9 +65,9 @@ export declare const ContextProviderPolicySchema: z.ZodObject<{
65
65
  maximumProviderHealthAgeSeconds: z.ZodDefault<z.ZodNumber>;
66
66
  maximumLatencyMs: z.ZodNumber;
67
67
  failureBehavior: z.ZodDefault<z.ZodEnum<{
68
+ await_input: "await_input";
68
69
  continue_without: "continue_without";
69
70
  fail: "fail";
70
- await_input: "await_input";
71
71
  }>>;
72
72
  }, z.core.$strip>;
73
73
  export declare const ContextContributionSchema: z.ZodObject<{
@@ -93,8 +93,8 @@ export declare const ContextContributionSchema: z.ZodObject<{
93
93
  citation: z.ZodOptional<z.ZodString>;
94
94
  sourceKind: z.ZodEnum<{
95
95
  external_evidence: "external_evidence";
96
- provider_memory: "provider_memory";
97
96
  provider_context: "provider_context";
97
+ provider_memory: "provider_memory";
98
98
  }>;
99
99
  }, z.core.$strip>>;
100
100
  providerMetadata: z.ZodOptional<z.ZodObject<{
@@ -114,14 +114,14 @@ export declare const ContextProviderReadModelSchema: z.ZodObject<{
114
114
  displayName: z.ZodString;
115
115
  contractVersion: z.ZodString;
116
116
  latencyClass: z.ZodDefault<z.ZodEnum<{
117
+ high: "high";
117
118
  low: "low";
118
119
  standard: "standard";
119
- high: "high";
120
120
  }>>;
121
121
  costClass: z.ZodDefault<z.ZodEnum<{
122
122
  low: "low";
123
- standard: "standard";
124
123
  premium: "premium";
124
+ standard: "standard";
125
125
  }>>;
126
126
  capabilities: z.ZodObject<{
127
127
  boundedRetrieval: z.ZodBoolean;
@@ -273,11 +273,11 @@ export declare const MarketplaceCatalogResponseSchema: z.ZodObject<{
273
273
  installationInstanceId: z.ZodOptional<z.ZodString>;
274
274
  packageDigest: z.ZodOptional<z.ZodString>;
275
275
  state: z.ZodEnum<{
276
- unavailable: "unavailable";
276
+ installed: "installed";
277
277
  "pending-authorization": "pending-authorization";
278
278
  "rejected-by-policy": "rejected-by-policy";
279
- installed: "installed";
280
279
  superseded: "superseded";
280
+ unavailable: "unavailable";
281
281
  }>;
282
282
  }, z.core.$strict>>;
283
283
  }, z.core.$strip>;
@@ -336,11 +336,11 @@ export declare const MarketplaceInstallResponseSchema: z.ZodObject<{
336
336
  packageDigest: z.ZodOptional<z.ZodString>;
337
337
  requestedHarness: z.ZodString;
338
338
  state: z.ZodEnum<{
339
- unavailable: "unavailable";
339
+ installed: "installed";
340
340
  "pending-authorization": "pending-authorization";
341
341
  "rejected-by-policy": "rejected-by-policy";
342
- installed: "installed";
343
342
  superseded: "superseded";
343
+ unavailable: "unavailable";
344
344
  }>;
345
345
  }, z.core.$strict>;
346
346
  }, z.core.$strip>;
@@ -397,9 +397,9 @@ export declare const MarketplaceInstallPlanResponseSchema: z.ZodObject<{
397
397
  releaseId: z.ZodString;
398
398
  instanceId: z.ZodString;
399
399
  strategy: z.ZodEnum<{
400
- unavailable: "unavailable";
401
- "native-agent-plugin": "native-agent-plugin";
402
400
  "component-adapter": "component-adapter";
401
+ "native-agent-plugin": "native-agent-plugin";
402
+ unavailable: "unavailable";
403
403
  }>;
404
404
  compatibility: z.ZodEnum<{
405
405
  full: "full";
@@ -418,15 +418,15 @@ export declare const RuntimeReadModelSchema: z.ZodObject<{
418
418
  runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
419
419
  family: z.ZodString;
420
420
  location: z.ZodEnum<{
421
+ agent_hq_cloud: "agent_hq_cloud";
421
422
  local_device: "local_device";
422
423
  remote_host: "remote_host";
423
- agent_hq_cloud: "agent_hq_cloud";
424
424
  }>;
425
425
  status: z.ZodEnum<{
426
- revoked: "revoked";
426
+ available: "available";
427
427
  degraded: "degraded";
428
+ revoked: "revoked";
428
429
  unavailable: "unavailable";
429
- available: "available";
430
430
  }>;
431
431
  observedAt: z.ZodISODateTime;
432
432
  capabilities: z.ZodArray<z.ZodString>;
@@ -453,10 +453,10 @@ export declare const RuntimeListRequestSchema: z.ZodObject<{
453
453
  requestedAt: z.ZodISODateTime;
454
454
  parameters: z.ZodObject<{
455
455
  status: z.ZodOptional<z.ZodEnum<{
456
- revoked: "revoked";
456
+ available: "available";
457
457
  degraded: "degraded";
458
+ revoked: "revoked";
458
459
  unavailable: "unavailable";
459
- available: "available";
460
460
  }>>;
461
461
  requiredCapabilities: z.ZodArray<z.ZodString>;
462
462
  }, z.core.$strip>;
@@ -479,15 +479,15 @@ export declare const RuntimeListResponseSchema: z.ZodObject<{
479
479
  runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
480
480
  family: z.ZodString;
481
481
  location: z.ZodEnum<{
482
+ agent_hq_cloud: "agent_hq_cloud";
482
483
  local_device: "local_device";
483
484
  remote_host: "remote_host";
484
- agent_hq_cloud: "agent_hq_cloud";
485
485
  }>;
486
486
  status: z.ZodEnum<{
487
- revoked: "revoked";
487
+ available: "available";
488
488
  degraded: "degraded";
489
+ revoked: "revoked";
489
490
  unavailable: "unavailable";
490
- available: "available";
491
491
  }>;
492
492
  observedAt: z.ZodISODateTime;
493
493
  capabilities: z.ZodArray<z.ZodString>;
@@ -656,9 +656,9 @@ export declare const ExecutionAcceptanceResponseSchema: z.ZodObject<{
656
656
  }, z.core.$strip>;
657
657
  status: z.ZodEnum<{
658
658
  accepted: "accepted";
659
- processing: "processing";
660
659
  completed: "completed";
661
660
  failed: "failed";
661
+ processing: "processing";
662
662
  reconciliation_required: "reconciliation_required";
663
663
  }>;
664
664
  replayed: z.ZodBoolean;
@@ -740,12 +740,12 @@ export declare const InteractionResponseCommandSchema: z.ZodObject<{
740
740
  interactionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"interaction ID">, string>>;
741
741
  expectedVersion: z.ZodNumber;
742
742
  action: z.ZodEnum<{
743
- input: "input";
744
743
  approve: "approve";
744
+ cancel: "cancel";
745
745
  deny: "deny";
746
746
  grant: "grant";
747
+ input: "input";
747
748
  resume: "resume";
748
- cancel: "cancel";
749
749
  }>;
750
750
  value: z.ZodOptional<z.ZodJSONSchema>;
751
751
  }, z.core.$strict>;
@@ -19,9 +19,9 @@ export declare const DECISION_RESOLUTION_CONTRACT_VERSION: Readonly<{
19
19
  /** Where a resolved output value came from. Precedence order is list order. */
20
20
  export declare const ResolutionSourceSchema: z.ZodEnum<{
21
21
  "explicit-pin": "explicit-pin";
22
- "project-default": "project-default";
23
- "profile-default": "profile-default";
24
22
  "policy-default": "policy-default";
23
+ "profile-default": "profile-default";
24
+ "project-default": "project-default";
25
25
  }>;
26
26
  export type ResolutionSource = z.output<typeof ResolutionSourceSchema>;
27
27
  /**
@@ -31,21 +31,21 @@ export type ResolutionSource = z.output<typeof ResolutionSourceSchema>;
31
31
  */
32
32
  export declare const SandboxResolutionSchema: z.ZodObject<{
33
33
  mode: z.ZodEnum<{
34
- none: "none";
35
34
  managed: "managed";
35
+ none: "none";
36
36
  }>;
37
37
  effectiveCapabilities: z.ZodArray<z.ZodString>;
38
38
  }, z.core.$strict>;
39
39
  export type SandboxResolution = z.output<typeof SandboxResolutionSchema>;
40
40
  export declare const DelegationResolutionSchema: z.ZodObject<{
41
41
  fanOut: z.ZodEnum<{
42
- none: "none";
43
42
  bounded: "bounded";
43
+ none: "none";
44
44
  }>;
45
45
  maxChildren: z.ZodOptional<z.ZodNumber>;
46
46
  promotion: z.ZodEnum<{
47
- "review-required": "review-required";
48
47
  "auto-eligible": "auto-eligible";
48
+ "review-required": "review-required";
49
49
  }>;
50
50
  }, z.core.$strict>;
51
51
  export type DelegationResolution = z.output<typeof DelegationResolutionSchema>;
@@ -71,37 +71,37 @@ export declare const DecisionPinsSchema: z.ZodObject<{
71
71
  }, z.core.$strict>>;
72
72
  sandbox: z.ZodOptional<z.ZodObject<{
73
73
  mode: z.ZodEnum<{
74
- none: "none";
75
74
  managed: "managed";
75
+ none: "none";
76
76
  }>;
77
77
  effectiveCapabilities: z.ZodArray<z.ZodString>;
78
78
  }, z.core.$strict>>;
79
79
  contextPackage: z.ZodOptional<z.ZodObject<{
80
80
  mode: z.ZodEnum<{
81
- none: "none";
82
- existing: "existing";
83
81
  author: "author";
82
+ existing: "existing";
83
+ none: "none";
84
84
  }>;
85
85
  contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
86
86
  }, z.core.$strict>>;
87
87
  delegation: z.ZodOptional<z.ZodObject<{
88
88
  fanOut: z.ZodEnum<{
89
- none: "none";
90
89
  bounded: "bounded";
90
+ none: "none";
91
91
  }>;
92
92
  maxChildren: z.ZodOptional<z.ZodNumber>;
93
93
  promotion: z.ZodEnum<{
94
- "review-required": "review-required";
95
94
  "auto-eligible": "auto-eligible";
95
+ "review-required": "review-required";
96
96
  }>;
97
97
  }, z.core.$strict>>;
98
98
  }, z.core.$strict>;
99
99
  export type DecisionPins = z.output<typeof DecisionPinsSchema>;
100
100
  export declare const ModelAccessEntitlementSchema: z.ZodEnum<{
101
- none: "none";
102
101
  byok: "byok";
103
- provisioned: "provisioned";
104
102
  "free-tier": "free-tier";
103
+ none: "none";
104
+ provisioned: "provisioned";
105
105
  }>;
106
106
  export type ModelAccessEntitlement = z.output<typeof ModelAccessEntitlementSchema>;
107
107
  export declare const AvailableRuntimeSchema: z.ZodObject<{
@@ -158,17 +158,17 @@ export declare const DecisionResolutionRequestSchema: z.ZodObject<{
158
158
  }, z.core.$strict>>;
159
159
  entitlements: z.ZodObject<{
160
160
  modelAccess: z.ZodEnum<{
161
- none: "none";
162
161
  byok: "byok";
163
- provisioned: "provisioned";
164
162
  "free-tier": "free-tier";
163
+ none: "none";
164
+ provisioned: "provisioned";
165
165
  }>;
166
166
  grantedCapabilityNames: z.ZodArray<z.ZodString>;
167
167
  }, z.core.$strict>;
168
168
  requiredCapabilities: z.ZodArray<z.ZodString>;
169
169
  costLatencyPreference: z.ZodEnum<{
170
- cost: "cost";
171
170
  balanced: "balanced";
171
+ cost: "cost";
172
172
  latency: "latency";
173
173
  }>;
174
174
  projectDefaults: z.ZodObject<{
@@ -189,28 +189,28 @@ export declare const DecisionResolutionRequestSchema: z.ZodObject<{
189
189
  }, z.core.$strict>>;
190
190
  sandbox: z.ZodOptional<z.ZodObject<{
191
191
  mode: z.ZodEnum<{
192
- none: "none";
193
192
  managed: "managed";
193
+ none: "none";
194
194
  }>;
195
195
  effectiveCapabilities: z.ZodArray<z.ZodString>;
196
196
  }, z.core.$strict>>;
197
197
  contextPackage: z.ZodOptional<z.ZodObject<{
198
198
  mode: z.ZodEnum<{
199
- none: "none";
200
- existing: "existing";
201
199
  author: "author";
200
+ existing: "existing";
201
+ none: "none";
202
202
  }>;
203
203
  contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
204
204
  }, z.core.$strict>>;
205
205
  delegation: z.ZodOptional<z.ZodObject<{
206
206
  fanOut: z.ZodEnum<{
207
- none: "none";
208
207
  bounded: "bounded";
208
+ none: "none";
209
209
  }>;
210
210
  maxChildren: z.ZodOptional<z.ZodNumber>;
211
211
  promotion: z.ZodEnum<{
212
- "review-required": "review-required";
213
212
  "auto-eligible": "auto-eligible";
213
+ "review-required": "review-required";
214
214
  }>;
215
215
  }, z.core.$strict>>;
216
216
  }, z.core.$strict>;
@@ -232,28 +232,28 @@ export declare const DecisionResolutionRequestSchema: z.ZodObject<{
232
232
  }, z.core.$strict>>;
233
233
  sandbox: z.ZodOptional<z.ZodObject<{
234
234
  mode: z.ZodEnum<{
235
- none: "none";
236
235
  managed: "managed";
236
+ none: "none";
237
237
  }>;
238
238
  effectiveCapabilities: z.ZodArray<z.ZodString>;
239
239
  }, z.core.$strict>>;
240
240
  contextPackage: z.ZodOptional<z.ZodObject<{
241
241
  mode: z.ZodEnum<{
242
- none: "none";
243
- existing: "existing";
244
242
  author: "author";
243
+ existing: "existing";
244
+ none: "none";
245
245
  }>;
246
246
  contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
247
247
  }, z.core.$strict>>;
248
248
  delegation: z.ZodOptional<z.ZodObject<{
249
249
  fanOut: z.ZodEnum<{
250
- none: "none";
251
250
  bounded: "bounded";
251
+ none: "none";
252
252
  }>;
253
253
  maxChildren: z.ZodOptional<z.ZodNumber>;
254
254
  promotion: z.ZodEnum<{
255
- "review-required": "review-required";
256
255
  "auto-eligible": "auto-eligible";
256
+ "review-required": "review-required";
257
257
  }>;
258
258
  }, z.core.$strict>>;
259
259
  }, z.core.$strict>;
@@ -275,28 +275,28 @@ export declare const DecisionResolutionRequestSchema: z.ZodObject<{
275
275
  }, z.core.$strict>>;
276
276
  sandbox: z.ZodOptional<z.ZodObject<{
277
277
  mode: z.ZodEnum<{
278
- none: "none";
279
278
  managed: "managed";
279
+ none: "none";
280
280
  }>;
281
281
  effectiveCapabilities: z.ZodArray<z.ZodString>;
282
282
  }, z.core.$strict>>;
283
283
  contextPackage: z.ZodOptional<z.ZodObject<{
284
284
  mode: z.ZodEnum<{
285
- none: "none";
286
- existing: "existing";
287
285
  author: "author";
286
+ existing: "existing";
287
+ none: "none";
288
288
  }>;
289
289
  contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
290
290
  }, z.core.$strict>>;
291
291
  delegation: z.ZodOptional<z.ZodObject<{
292
292
  fanOut: z.ZodEnum<{
293
- none: "none";
294
293
  bounded: "bounded";
294
+ none: "none";
295
295
  }>;
296
296
  maxChildren: z.ZodOptional<z.ZodNumber>;
297
297
  promotion: z.ZodEnum<{
298
- "review-required": "review-required";
299
298
  "auto-eligible": "auto-eligible";
299
+ "review-required": "review-required";
300
300
  }>;
301
301
  }, z.core.$strict>>;
302
302
  }, z.core.$strict>;
@@ -304,21 +304,21 @@ export declare const DecisionResolutionRequestSchema: z.ZodObject<{
304
304
  export type DecisionResolutionRequest = z.output<typeof DecisionResolutionRequestSchema>;
305
305
  /** Fail-closed denial codes; a denial never narrows silently. */
306
306
  export declare const DecisionResolutionDiagnosticSchema: z.ZodEnum<{
307
- UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
308
- MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
309
- NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
310
307
  CAPABILITY_BEYOND_GRANT: "CAPABILITY_BEYOND_GRANT";
311
- HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
312
308
  CONTEXT_PACKAGE_PIN_MISMATCH: "CONTEXT_PACKAGE_PIN_MISMATCH";
309
+ HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
310
+ MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
311
+ NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
312
+ UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
313
313
  }>;
314
314
  export type DecisionResolutionDiagnostic = z.output<typeof DecisionResolutionDiagnosticSchema>;
315
315
  /** One resolved output plus the precedence layer it came from. */
316
316
  export declare const ResolvedOutputSchema: z.ZodObject<{
317
317
  source: z.ZodEnum<{
318
318
  "explicit-pin": "explicit-pin";
319
- "project-default": "project-default";
320
- "profile-default": "profile-default";
321
319
  "policy-default": "policy-default";
320
+ "profile-default": "profile-default";
321
+ "project-default": "project-default";
322
322
  }>;
323
323
  value: z.ZodJSONSchema;
324
324
  }, z.core.$strict>;
@@ -340,12 +340,12 @@ export declare const DecisionLayerResolutionSchema: z.ZodObject<{
340
340
  modelId: z.ZodString;
341
341
  }, z.core.$strict>, z.ZodObject<{
342
342
  withheld: z.ZodEnum<{
343
- UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
344
- MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
345
- NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
346
343
  CAPABILITY_BEYOND_GRANT: "CAPABILITY_BEYOND_GRANT";
347
- HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
348
344
  CONTEXT_PACKAGE_PIN_MISMATCH: "CONTEXT_PACKAGE_PIN_MISMATCH";
345
+ HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
346
+ MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
347
+ NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
348
+ UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
349
349
  }>;
350
350
  }, z.core.$strict>]>;
351
351
  skills: z.ZodObject<{
@@ -370,47 +370,47 @@ export declare const DecisionLayerResolutionSchema: z.ZodObject<{
370
370
  }, z.core.$strict>;
371
371
  sandbox: z.ZodObject<{
372
372
  mode: z.ZodEnum<{
373
- none: "none";
374
373
  managed: "managed";
374
+ none: "none";
375
375
  }>;
376
376
  effectiveCapabilities: z.ZodArray<z.ZodString>;
377
377
  }, z.core.$strict>;
378
378
  contextPackage: z.ZodObject<{
379
379
  mode: z.ZodEnum<{
380
- none: "none";
381
- existing: "existing";
382
380
  author: "author";
381
+ existing: "existing";
382
+ none: "none";
383
383
  }>;
384
384
  contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
385
385
  }, z.core.$strict>;
386
386
  delegation: z.ZodObject<{
387
387
  fanOut: z.ZodEnum<{
388
- none: "none";
389
388
  bounded: "bounded";
389
+ none: "none";
390
390
  }>;
391
391
  maxChildren: z.ZodOptional<z.ZodNumber>;
392
392
  promotion: z.ZodEnum<{
393
- "review-required": "review-required";
394
393
  "auto-eligible": "auto-eligible";
394
+ "review-required": "review-required";
395
395
  }>;
396
396
  }, z.core.$strict>;
397
397
  }, z.core.$strict>;
398
398
  trace: z.ZodRecord<z.ZodString, z.ZodObject<{
399
399
  source: z.ZodEnum<{
400
400
  "explicit-pin": "explicit-pin";
401
- "project-default": "project-default";
402
- "profile-default": "profile-default";
403
401
  "policy-default": "policy-default";
402
+ "profile-default": "profile-default";
403
+ "project-default": "project-default";
404
404
  }>;
405
405
  value: z.ZodJSONSchema;
406
406
  }, z.core.$strict>>;
407
407
  diagnostics: z.ZodArray<z.ZodEnum<{
408
- UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
409
- MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
410
- NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
411
408
  CAPABILITY_BEYOND_GRANT: "CAPABILITY_BEYOND_GRANT";
412
- HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
413
409
  CONTEXT_PACKAGE_PIN_MISMATCH: "CONTEXT_PACKAGE_PIN_MISMATCH";
410
+ HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
411
+ MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
412
+ NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
413
+ UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
414
414
  }>>;
415
415
  resolutionDigest: z.ZodString;
416
416
  }, z.core.$strict>;
@@ -64,39 +64,39 @@ export declare const SuccessResponseEnvelopeSchema: z.ZodObject<{
64
64
  data: z.ZodUnknown;
65
65
  }, z.core.$strip>;
66
66
  export declare const ErrorClassSchema: z.ZodEnum<{
67
- validation: "validation";
68
67
  authentication: "authentication";
69
68
  authorization: "authorization";
70
- conflict: "conflict";
71
- stale_reference: "stale_reference";
72
69
  capability_mismatch: "capability_mismatch";
73
- runtime_unavailable: "runtime_unavailable";
70
+ conflict: "conflict";
74
71
  internal: "internal";
72
+ runtime_unavailable: "runtime_unavailable";
73
+ stale_reference: "stale_reference";
74
+ validation: "validation";
75
75
  }>;
76
76
  export type ErrorClass = z.infer<typeof ErrorClassSchema>;
77
77
  export declare const NormalizedErrorSchema: z.ZodObject<{
78
78
  class: z.ZodEnum<{
79
- validation: "validation";
80
79
  authentication: "authentication";
81
80
  authorization: "authorization";
82
- conflict: "conflict";
83
- stale_reference: "stale_reference";
84
81
  capability_mismatch: "capability_mismatch";
85
- runtime_unavailable: "runtime_unavailable";
82
+ conflict: "conflict";
86
83
  internal: "internal";
84
+ runtime_unavailable: "runtime_unavailable";
85
+ stale_reference: "stale_reference";
86
+ validation: "validation";
87
87
  }>;
88
88
  code: z.ZodString;
89
89
  message: z.ZodString;
90
90
  retryable: z.ZodBoolean;
91
91
  source: z.ZodEnum<{
92
- provider: "provider";
93
- client: "client";
94
92
  auth: "auth";
93
+ client: "client";
94
+ persistence: "persistence";
95
95
  policy: "policy";
96
+ provider: "provider";
96
97
  runtime: "runtime";
97
- persistence: "persistence";
98
- workflow: "workflow";
99
98
  system: "system";
99
+ workflow: "workflow";
100
100
  }>;
101
101
  remediation: z.ZodOptional<z.ZodString>;
102
102
  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -115,27 +115,27 @@ export declare const ErrorResponseEnvelopeSchema: z.ZodObject<{
115
115
  }, z.core.$strip>;
116
116
  error: z.ZodObject<{
117
117
  class: z.ZodEnum<{
118
- validation: "validation";
119
118
  authentication: "authentication";
120
119
  authorization: "authorization";
121
- conflict: "conflict";
122
- stale_reference: "stale_reference";
123
120
  capability_mismatch: "capability_mismatch";
124
- runtime_unavailable: "runtime_unavailable";
121
+ conflict: "conflict";
125
122
  internal: "internal";
123
+ runtime_unavailable: "runtime_unavailable";
124
+ stale_reference: "stale_reference";
125
+ validation: "validation";
126
126
  }>;
127
127
  code: z.ZodString;
128
128
  message: z.ZodString;
129
129
  retryable: z.ZodBoolean;
130
130
  source: z.ZodEnum<{
131
- provider: "provider";
132
- client: "client";
133
131
  auth: "auth";
132
+ client: "client";
133
+ persistence: "persistence";
134
134
  policy: "policy";
135
+ provider: "provider";
135
136
  runtime: "runtime";
136
- persistence: "persistence";
137
- workflow: "workflow";
138
137
  system: "system";
138
+ workflow: "workflow";
139
139
  }>;
140
140
  remediation: z.ZodOptional<z.ZodString>;
141
141
  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -166,27 +166,27 @@ export declare const ResponseEnvelopeSchema: z.ZodUnion<readonly [z.ZodObject<{
166
166
  }, z.core.$strip>;
167
167
  error: z.ZodObject<{
168
168
  class: z.ZodEnum<{
169
- validation: "validation";
170
169
  authentication: "authentication";
171
170
  authorization: "authorization";
172
- conflict: "conflict";
173
- stale_reference: "stale_reference";
174
171
  capability_mismatch: "capability_mismatch";
175
- runtime_unavailable: "runtime_unavailable";
172
+ conflict: "conflict";
176
173
  internal: "internal";
174
+ runtime_unavailable: "runtime_unavailable";
175
+ stale_reference: "stale_reference";
176
+ validation: "validation";
177
177
  }>;
178
178
  code: z.ZodString;
179
179
  message: z.ZodString;
180
180
  retryable: z.ZodBoolean;
181
181
  source: z.ZodEnum<{
182
- provider: "provider";
183
- client: "client";
184
182
  auth: "auth";
183
+ client: "client";
184
+ persistence: "persistence";
185
185
  policy: "policy";
186
+ provider: "provider";
186
187
  runtime: "runtime";
187
- persistence: "persistence";
188
- workflow: "workflow";
189
188
  system: "system";
189
+ workflow: "workflow";
190
190
  }>;
191
191
  remediation: z.ZodOptional<z.ZodString>;
192
192
  details: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -284,10 +284,10 @@ export declare const RuntimeReadModelEnvelopeSchema: z.ZodObject<{
284
284
  runtimeNodeRefId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-node reference ID">, string>>;
285
285
  runtimeConnectionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-connection ID">, string>>>;
286
286
  status: z.ZodEnum<{
287
- revoked: "revoked";
287
+ available: "available";
288
288
  degraded: "degraded";
289
+ revoked: "revoked";
289
290
  unavailable: "unavailable";
290
- available: "available";
291
291
  }>;
292
292
  observedAt: z.ZodISODateTime;
293
293
  readModel: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -83,8 +83,8 @@ export declare const PublicContractFixtures: Readonly<{
83
83
  workspaceId: string;
84
84
  projectId: string;
85
85
  correlation: {
86
- causationCommandId: string;
87
86
  traceId: string;
87
+ causationCommandId: string;
88
88
  };
89
89
  data: {
90
90
  executionId: string;
@@ -1 +1 @@
1
- {"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../src/fixtures.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqFjC,CAAA"}
1
+ {"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../src/fixtures.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB;;;;;;4BATF,CAAC;4BAAS,CAAC;;;;;;;;;;;;;;YAsB7B,SAAS;;;;;;;;;;;;;;;;;;;;YAWN,MAAM;;;;;;;;;;;;;YAMZ,QAAQ;;;;;;;;;;;;;YAOd,KAAK;YACL,IAAI;YACJ,OAAO;YACP,SAAS;YACT,MAAM;;;;;;;;;;;;;;;;;;YAWA,WAAW;;;;;;;;;;;;;;;;YAUjB,WAAW;YACX,YAAY;YACZ,UAAU;YACV,IAAI;gBAAI,MAAM;gBAAY,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;YAkBvB,QAAQ;YAAW,OAAO;;;EAEzC,CAAA"}