@adea-ai/contracts 1.11.0 → 1.12.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.
@@ -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"}
@@ -0,0 +1,123 @@
1
+ import { z } from 'zod';
2
+ export declare const GraphReferenceSchema: z.ZodObject<{
3
+ graphDefinitionId: z.ZodString;
4
+ graphVersion: z.ZodString;
5
+ contentDigest: z.ZodString;
6
+ }, z.core.$strict>;
7
+ export type GraphReference = z.output<typeof GraphReferenceSchema>;
8
+ export declare const GraphDefinitionContentSchema: z.ZodObject<{
9
+ graphDefinitionId: z.ZodString;
10
+ graphVersion: z.ZodString;
11
+ schemaVersion: z.ZodLiteral<1>;
12
+ nodes: z.ZodArray<z.ZodObject<{
13
+ node: z.ZodString;
14
+ join: z.ZodOptional<z.ZodEnum<{
15
+ all: "all";
16
+ any: "any";
17
+ }>>;
18
+ operation: z.ZodObject<{
19
+ kind: z.ZodEnum<{
20
+ delegation: "delegation";
21
+ model: "model";
22
+ runtime: "runtime";
23
+ tool: "tool";
24
+ }>;
25
+ name: z.ZodString;
26
+ }, z.core.$strict>;
27
+ }, z.core.$strict>>;
28
+ edges: z.ZodArray<z.ZodObject<{
29
+ from: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"__start__">]>;
30
+ to: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"__end__">]>;
31
+ when: z.ZodOptional<z.ZodObject<{
32
+ path: z.ZodArray<z.ZodString>;
33
+ equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
34
+ }, z.core.$strict>>;
35
+ }, z.core.$strict>>;
36
+ schemas: z.ZodObject<{
37
+ input: z.ZodString;
38
+ state: z.ZodString;
39
+ output: z.ZodString;
40
+ }, z.core.$strict>;
41
+ requiredCapabilities: z.ZodArray<z.ZodString>;
42
+ compatibility: z.ZodObject<{
43
+ contractMajorVersions: z.ZodArray<z.ZodNumber>;
44
+ compilerVersions: z.ZodArray<z.ZodString>;
45
+ adapterVersions: z.ZodArray<z.ZodString>;
46
+ }, z.core.$strict>;
47
+ }, z.core.$strict>;
48
+ /** Public catalog snapshot; the server additionally verifies the content digest. */
49
+ export declare const GraphDefinitionVersionSchema: z.ZodObject<{
50
+ reference: z.ZodObject<{
51
+ graphDefinitionId: z.ZodString;
52
+ graphVersion: z.ZodString;
53
+ contentDigest: z.ZodString;
54
+ }, z.core.$strict>;
55
+ revision: z.ZodNumber;
56
+ lifecycle: z.ZodEnum<{
57
+ deprecated: "deprecated";
58
+ published: "published";
59
+ revoked: "revoked";
60
+ }>;
61
+ content: z.ZodObject<{
62
+ graphDefinitionId: z.ZodString;
63
+ graphVersion: z.ZodString;
64
+ schemaVersion: z.ZodLiteral<1>;
65
+ nodes: z.ZodArray<z.ZodObject<{
66
+ node: z.ZodString;
67
+ join: z.ZodOptional<z.ZodEnum<{
68
+ all: "all";
69
+ any: "any";
70
+ }>>;
71
+ operation: z.ZodObject<{
72
+ kind: z.ZodEnum<{
73
+ delegation: "delegation";
74
+ model: "model";
75
+ runtime: "runtime";
76
+ tool: "tool";
77
+ }>;
78
+ name: z.ZodString;
79
+ }, z.core.$strict>;
80
+ }, z.core.$strict>>;
81
+ edges: z.ZodArray<z.ZodObject<{
82
+ from: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"__start__">]>;
83
+ to: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"__end__">]>;
84
+ when: z.ZodOptional<z.ZodObject<{
85
+ path: z.ZodArray<z.ZodString>;
86
+ equals: z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean, z.ZodNull]>;
87
+ }, z.core.$strict>>;
88
+ }, z.core.$strict>>;
89
+ schemas: z.ZodObject<{
90
+ input: z.ZodString;
91
+ state: z.ZodString;
92
+ output: z.ZodString;
93
+ }, z.core.$strict>;
94
+ requiredCapabilities: z.ZodArray<z.ZodString>;
95
+ compatibility: z.ZodObject<{
96
+ contractMajorVersions: z.ZodArray<z.ZodNumber>;
97
+ compilerVersions: z.ZodArray<z.ZodString>;
98
+ adapterVersions: z.ZodArray<z.ZodString>;
99
+ }, z.core.$strict>;
100
+ }, z.core.$strict>;
101
+ publishedAt: z.ZodISODateTime;
102
+ changedAt: z.ZodISODateTime;
103
+ reason: z.ZodOptional<z.ZodString>;
104
+ }, z.core.$strict>;
105
+ export type GraphDefinitionVersion = z.output<typeof GraphDefinitionVersionSchema>;
106
+ export type GraphJsonValue = null | boolean | number | string | GraphJsonValue[] | {
107
+ [key: string]: GraphJsonValue;
108
+ };
109
+ export type GraphInput = {
110
+ [key: string]: GraphJsonValue;
111
+ };
112
+ export declare const GraphInputSchema: z.ZodPipe<z.ZodCustom<GraphInput, GraphInput>, z.ZodTransform<GraphInput, GraphInput>>;
113
+ export declare const GraphSelectionSchema: z.ZodObject<{
114
+ reference: z.ZodObject<{
115
+ graphDefinitionId: z.ZodString;
116
+ graphVersion: z.ZodString;
117
+ contentDigest: z.ZodString;
118
+ }, z.core.$strict>;
119
+ input: z.ZodPipe<z.ZodCustom<GraphInput, GraphInput>, z.ZodTransform<GraphInput, GraphInput>>;
120
+ }, z.core.$strict>;
121
+ export type GraphSelection = z.output<typeof GraphSelectionSchema>;
122
+ export type GraphDefinitionContent = z.output<typeof GraphDefinitionContentSchema>;
123
+ //# sourceMappingURL=graphs.d.ts.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"graphs.d.ts","sourceRoot":"","sources":["../src/graphs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,eAAO,MAAM,oBAAoB;;;;kBAMtB,CAAA;AACX,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAQlE,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAkFrC,CAAA;AAEJ,oFAAoF;AACpF,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoBrC,CAAA;AACJ,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAA;AAElF,MAAM,MAAM,cAAc,GACtB,IAAI,GACJ,OAAO,GACP,MAAM,GACN,MAAM,GACN,cAAc,EAAE,GAChB;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA;AACrC,MAAM,MAAM,UAAU,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,cAAc,CAAA;CAAE,CAAA;AAyD1D,eAAO,MAAM,gBAAgB,wFASzB,CAAA;AACJ,eAAO,MAAM,oBAAoB;;;;;;;kBAEtB,CAAA;AACX,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAClE,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,4BAA4B,CAAC,CAAA"}