@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.
- package/dist/authentication.d.ts +4 -4
- package/dist/context-providers.d.ts +6 -6
- package/dist/control-api.d.ts +256 -17
- package/dist/control-api.d.ts.map +1 -1
- package/dist/control-api.js +33 -0
- package/dist/control-api.js.map +1 -1
- package/dist/decision-resolution.d.ts +51 -51
- package/dist/envelopes.d.ts +30 -30
- package/dist/fixtures.d.ts +1 -1
- package/dist/fixtures.d.ts.map +1 -1
- package/dist/graphs.d.ts +123 -0
- package/dist/graphs.d.ts.map +1 -0
- package/dist/graphs.js +196 -0
- package/dist/graphs.js.map +1 -0
- package/dist/identifiers.d.ts.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/memory-writeback.d.ts +19 -19
- package/dist/runtime-discovery.d.ts +123 -123
- package/dist/versioning.d.ts.map +1 -1
- package/package.json +2 -2
|
@@ -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>;
|
package/dist/envelopes.d.ts
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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>;
|
package/dist/fixtures.d.ts
CHANGED
package/dist/fixtures.d.ts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"fixtures.d.ts","sourceRoot":"","sources":["../src/fixtures.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,sBAAsB
|
|
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"}
|
package/dist/graphs.d.ts
ADDED
|
@@ -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"}
|