@adea-ai/contracts 3.0.0 → 3.1.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/control-api.d.ts +526 -32
- package/dist/control-api.js +48 -27
- package/dist/decision-resolution.d.ts +110 -12
- package/dist/decision-resolution.js +86 -34
- package/dist/device-sync.d.ts +128 -0
- package/dist/device-sync.js +115 -0
- package/dist/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/dist/model-connections.d.ts +8 -0
- package/dist/model-connections.js +12 -2
- package/package.json +6 -3
package/dist/control-api.d.ts
CHANGED
|
@@ -90,6 +90,322 @@ export declare const ProfileResolutionRequestSchema: z.ZodObject<{
|
|
|
90
90
|
profileVersionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"profile-version ID">, string>>>;
|
|
91
91
|
}, z.core.$strip>;
|
|
92
92
|
}, z.core.$strip>;
|
|
93
|
+
/**
|
|
94
|
+
* The decision layer (control-plane#558) over the public API. The envelope carries the request
|
|
95
|
+
* identity; `parameters` are the decision inputs. Every composition resolves with the same
|
|
96
|
+
* policy, so a desktop or VPS Local composition and managed cloud answer alike, and nothing here
|
|
97
|
+
* executes.
|
|
98
|
+
*/
|
|
99
|
+
export declare const DecisionResolveRequestSchema: z.ZodObject<{
|
|
100
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
101
|
+
contractVersion: typeof ContractVersionSchema;
|
|
102
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
103
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
104
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
105
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
106
|
+
operation: z.ZodLiteral<"decision.resolve">;
|
|
107
|
+
requestedAt: typeof TimestampSchema;
|
|
108
|
+
parameters: z.ZodObject<{
|
|
109
|
+
objective: z.ZodString;
|
|
110
|
+
mode: z.ZodOptional<z.ZodEnum<{
|
|
111
|
+
auto: "auto";
|
|
112
|
+
customize: "customize";
|
|
113
|
+
}>>;
|
|
114
|
+
agentProfile: z.ZodObject<{
|
|
115
|
+
profileId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"profile ID">, string>>;
|
|
116
|
+
profileVersionId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"profile-version ID">, string>>>;
|
|
117
|
+
}, z.core.$strict>;
|
|
118
|
+
availableRuntimes: z.ZodArray<z.ZodObject<{
|
|
119
|
+
runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
|
|
120
|
+
kind: z.ZodEnum<{
|
|
121
|
+
local: "local";
|
|
122
|
+
}>;
|
|
123
|
+
host: z.ZodEnum<{
|
|
124
|
+
desktop: "desktop";
|
|
125
|
+
vps: "vps";
|
|
126
|
+
}>;
|
|
127
|
+
transport: z.ZodEnum<{
|
|
128
|
+
"direct-local": "direct-local";
|
|
129
|
+
}>;
|
|
130
|
+
harnessIds: z.ZodArray<z.ZodString>;
|
|
131
|
+
capabilities: z.ZodArray<z.ZodString>;
|
|
132
|
+
}, z.core.$strict>>;
|
|
133
|
+
entitlements: z.ZodObject<{
|
|
134
|
+
modelAccess: z.ZodEnum<{
|
|
135
|
+
byok: "byok";
|
|
136
|
+
"free-tier": "free-tier";
|
|
137
|
+
none: "none";
|
|
138
|
+
provisioned: "provisioned";
|
|
139
|
+
}>;
|
|
140
|
+
grantedCapabilityNames: z.ZodArray<z.ZodString>;
|
|
141
|
+
}, z.core.$strict>;
|
|
142
|
+
requiredCapabilities: z.ZodArray<z.ZodString>;
|
|
143
|
+
availableSkills: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
144
|
+
skillVersionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"skill-version ID">, string>>;
|
|
145
|
+
requiredCapabilities: z.ZodArray<z.ZodString>;
|
|
146
|
+
}, z.core.$strict>>>;
|
|
147
|
+
costLatencyPreference: z.ZodEnum<{
|
|
148
|
+
balanced: "balanced";
|
|
149
|
+
cost: "cost";
|
|
150
|
+
latency: "latency";
|
|
151
|
+
}>;
|
|
152
|
+
projectDefaults: z.ZodObject<{
|
|
153
|
+
harness: z.ZodOptional<z.ZodObject<{
|
|
154
|
+
harnessId: z.ZodString;
|
|
155
|
+
}, z.core.$strict>>;
|
|
156
|
+
model: z.ZodOptional<z.ZodObject<{
|
|
157
|
+
modelId: z.ZodString;
|
|
158
|
+
}, z.core.$strict>>;
|
|
159
|
+
skills: z.ZodOptional<z.ZodObject<{
|
|
160
|
+
skillVersionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"skill-version ID">, string>>>;
|
|
161
|
+
}, z.core.$strict>>;
|
|
162
|
+
capabilities: z.ZodOptional<z.ZodObject<{
|
|
163
|
+
capabilityNames: z.ZodArray<z.ZodString>;
|
|
164
|
+
}, z.core.$strict>>;
|
|
165
|
+
runtime: z.ZodOptional<z.ZodObject<{
|
|
166
|
+
runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
|
|
167
|
+
}, z.core.$strict>>;
|
|
168
|
+
sandbox: z.ZodOptional<z.ZodObject<{
|
|
169
|
+
mode: z.ZodEnum<{
|
|
170
|
+
managed: "managed";
|
|
171
|
+
none: "none";
|
|
172
|
+
}>;
|
|
173
|
+
effectiveCapabilities: z.ZodArray<z.ZodString>;
|
|
174
|
+
}, z.core.$strict>>;
|
|
175
|
+
contextPackage: z.ZodOptional<z.ZodObject<{
|
|
176
|
+
mode: z.ZodEnum<{
|
|
177
|
+
author: "author";
|
|
178
|
+
existing: "existing";
|
|
179
|
+
none: "none";
|
|
180
|
+
}>;
|
|
181
|
+
contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
|
|
182
|
+
}, z.core.$strict>>;
|
|
183
|
+
delegation: z.ZodOptional<z.ZodObject<{
|
|
184
|
+
fanOut: z.ZodEnum<{
|
|
185
|
+
bounded: "bounded";
|
|
186
|
+
none: "none";
|
|
187
|
+
}>;
|
|
188
|
+
maxChildren: z.ZodOptional<z.ZodNumber>;
|
|
189
|
+
promotion: z.ZodEnum<{
|
|
190
|
+
"auto-eligible": "auto-eligible";
|
|
191
|
+
"review-required": "review-required";
|
|
192
|
+
}>;
|
|
193
|
+
}, z.core.$strict>>;
|
|
194
|
+
}, z.core.$strict>;
|
|
195
|
+
profileDefaults: z.ZodObject<{
|
|
196
|
+
harness: z.ZodOptional<z.ZodObject<{
|
|
197
|
+
harnessId: z.ZodString;
|
|
198
|
+
}, z.core.$strict>>;
|
|
199
|
+
model: z.ZodOptional<z.ZodObject<{
|
|
200
|
+
modelId: z.ZodString;
|
|
201
|
+
}, z.core.$strict>>;
|
|
202
|
+
skills: z.ZodOptional<z.ZodObject<{
|
|
203
|
+
skillVersionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"skill-version ID">, string>>>;
|
|
204
|
+
}, z.core.$strict>>;
|
|
205
|
+
capabilities: z.ZodOptional<z.ZodObject<{
|
|
206
|
+
capabilityNames: z.ZodArray<z.ZodString>;
|
|
207
|
+
}, z.core.$strict>>;
|
|
208
|
+
runtime: z.ZodOptional<z.ZodObject<{
|
|
209
|
+
runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
|
|
210
|
+
}, z.core.$strict>>;
|
|
211
|
+
sandbox: z.ZodOptional<z.ZodObject<{
|
|
212
|
+
mode: z.ZodEnum<{
|
|
213
|
+
managed: "managed";
|
|
214
|
+
none: "none";
|
|
215
|
+
}>;
|
|
216
|
+
effectiveCapabilities: z.ZodArray<z.ZodString>;
|
|
217
|
+
}, z.core.$strict>>;
|
|
218
|
+
contextPackage: z.ZodOptional<z.ZodObject<{
|
|
219
|
+
mode: z.ZodEnum<{
|
|
220
|
+
author: "author";
|
|
221
|
+
existing: "existing";
|
|
222
|
+
none: "none";
|
|
223
|
+
}>;
|
|
224
|
+
contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
|
|
225
|
+
}, z.core.$strict>>;
|
|
226
|
+
delegation: z.ZodOptional<z.ZodObject<{
|
|
227
|
+
fanOut: z.ZodEnum<{
|
|
228
|
+
bounded: "bounded";
|
|
229
|
+
none: "none";
|
|
230
|
+
}>;
|
|
231
|
+
maxChildren: z.ZodOptional<z.ZodNumber>;
|
|
232
|
+
promotion: z.ZodEnum<{
|
|
233
|
+
"auto-eligible": "auto-eligible";
|
|
234
|
+
"review-required": "review-required";
|
|
235
|
+
}>;
|
|
236
|
+
}, z.core.$strict>>;
|
|
237
|
+
}, z.core.$strict>;
|
|
238
|
+
explicitPins: z.ZodObject<{
|
|
239
|
+
harness: z.ZodOptional<z.ZodObject<{
|
|
240
|
+
harnessId: z.ZodString;
|
|
241
|
+
}, z.core.$strict>>;
|
|
242
|
+
model: z.ZodOptional<z.ZodObject<{
|
|
243
|
+
modelId: z.ZodString;
|
|
244
|
+
}, z.core.$strict>>;
|
|
245
|
+
skills: z.ZodOptional<z.ZodObject<{
|
|
246
|
+
skillVersionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"skill-version ID">, string>>>;
|
|
247
|
+
}, z.core.$strict>>;
|
|
248
|
+
capabilities: z.ZodOptional<z.ZodObject<{
|
|
249
|
+
capabilityNames: z.ZodArray<z.ZodString>;
|
|
250
|
+
}, z.core.$strict>>;
|
|
251
|
+
runtime: z.ZodOptional<z.ZodObject<{
|
|
252
|
+
runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
|
|
253
|
+
}, z.core.$strict>>;
|
|
254
|
+
sandbox: z.ZodOptional<z.ZodObject<{
|
|
255
|
+
mode: z.ZodEnum<{
|
|
256
|
+
managed: "managed";
|
|
257
|
+
none: "none";
|
|
258
|
+
}>;
|
|
259
|
+
effectiveCapabilities: z.ZodArray<z.ZodString>;
|
|
260
|
+
}, z.core.$strict>>;
|
|
261
|
+
contextPackage: z.ZodOptional<z.ZodObject<{
|
|
262
|
+
mode: z.ZodEnum<{
|
|
263
|
+
author: "author";
|
|
264
|
+
existing: "existing";
|
|
265
|
+
none: "none";
|
|
266
|
+
}>;
|
|
267
|
+
contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
|
|
268
|
+
}, z.core.$strict>>;
|
|
269
|
+
delegation: z.ZodOptional<z.ZodObject<{
|
|
270
|
+
fanOut: z.ZodEnum<{
|
|
271
|
+
bounded: "bounded";
|
|
272
|
+
none: "none";
|
|
273
|
+
}>;
|
|
274
|
+
maxChildren: z.ZodOptional<z.ZodNumber>;
|
|
275
|
+
promotion: z.ZodEnum<{
|
|
276
|
+
"auto-eligible": "auto-eligible";
|
|
277
|
+
"review-required": "review-required";
|
|
278
|
+
}>;
|
|
279
|
+
}, z.core.$strict>>;
|
|
280
|
+
}, z.core.$strict>;
|
|
281
|
+
}, z.core.$strict>;
|
|
282
|
+
}, z.core.$strip>;
|
|
283
|
+
export declare const DecisionResolveResponseSchema: z.ZodObject<{
|
|
284
|
+
contractVersion: typeof ContractVersionSchema;
|
|
285
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
286
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
287
|
+
data: z.ZodObject<{
|
|
288
|
+
schemaVersion: z.ZodNumber;
|
|
289
|
+
requestId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"request ID">, string>>;
|
|
290
|
+
workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"workspace ID">, string>>;
|
|
291
|
+
contractVersion: z.ZodObject<{
|
|
292
|
+
major: z.ZodNumber;
|
|
293
|
+
minor: z.ZodNumber;
|
|
294
|
+
}, z.core.$strict>;
|
|
295
|
+
resolvedAt: z.ZodISODateTime;
|
|
296
|
+
mode: z.ZodEnum<{
|
|
297
|
+
auto: "auto";
|
|
298
|
+
customize: "customize";
|
|
299
|
+
}>;
|
|
300
|
+
resolution: z.ZodObject<{
|
|
301
|
+
harness: z.ZodObject<{
|
|
302
|
+
harnessId: z.ZodString;
|
|
303
|
+
}, z.core.$strict>;
|
|
304
|
+
model: z.ZodUnion<readonly [z.ZodObject<{
|
|
305
|
+
modelId: z.ZodString;
|
|
306
|
+
}, z.core.$strict>, z.ZodObject<{
|
|
307
|
+
withheld: z.ZodEnum<{
|
|
308
|
+
AUTO_MODE_EXPLICIT_PIN: "AUTO_MODE_EXPLICIT_PIN";
|
|
309
|
+
CAPABILITY_BEYOND_GRANT: "CAPABILITY_BEYOND_GRANT";
|
|
310
|
+
CONTEXT_PACKAGE_PIN_MISMATCH: "CONTEXT_PACKAGE_PIN_MISMATCH";
|
|
311
|
+
DELEGATION_BEYOND_POLICY: "DELEGATION_BEYOND_POLICY";
|
|
312
|
+
HARNESS_MAP_CONFLICTS_WITH_PIN: "HARNESS_MAP_CONFLICTS_WITH_PIN";
|
|
313
|
+
HARNESS_MAP_MODEL_ABSENT: "HARNESS_MAP_MODEL_ABSENT";
|
|
314
|
+
HARNESS_MAP_MODEL_UNMAPPED: "HARNESS_MAP_MODEL_UNMAPPED";
|
|
315
|
+
HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
|
|
316
|
+
MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
|
|
317
|
+
NO_COMPATIBLE_RUNTIME: "NO_COMPATIBLE_RUNTIME";
|
|
318
|
+
NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
|
|
319
|
+
SKILL_BEYOND_CAPABILITIES: "SKILL_BEYOND_CAPABILITIES";
|
|
320
|
+
SKILL_UNAVAILABLE: "SKILL_UNAVAILABLE";
|
|
321
|
+
UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
|
|
322
|
+
}>;
|
|
323
|
+
}, z.core.$strict>]>;
|
|
324
|
+
skills: z.ZodObject<{
|
|
325
|
+
skillVersionIds: z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"skill-version ID">, string>>>;
|
|
326
|
+
}, z.core.$strict>;
|
|
327
|
+
capabilities: z.ZodObject<{
|
|
328
|
+
capabilityNames: z.ZodArray<z.ZodString>;
|
|
329
|
+
}, z.core.$strict>;
|
|
330
|
+
runtime: z.ZodObject<{
|
|
331
|
+
runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
|
|
332
|
+
kind: z.ZodEnum<{
|
|
333
|
+
local: "local";
|
|
334
|
+
}>;
|
|
335
|
+
host: z.ZodEnum<{
|
|
336
|
+
desktop: "desktop";
|
|
337
|
+
vps: "vps";
|
|
338
|
+
}>;
|
|
339
|
+
transport: z.ZodEnum<{
|
|
340
|
+
"direct-local": "direct-local";
|
|
341
|
+
}>;
|
|
342
|
+
harnessIds: z.ZodArray<z.ZodString>;
|
|
343
|
+
capabilities: z.ZodArray<z.ZodString>;
|
|
344
|
+
}, z.core.$strict>;
|
|
345
|
+
sandbox: z.ZodObject<{
|
|
346
|
+
mode: z.ZodEnum<{
|
|
347
|
+
managed: "managed";
|
|
348
|
+
none: "none";
|
|
349
|
+
}>;
|
|
350
|
+
effectiveCapabilities: z.ZodArray<z.ZodString>;
|
|
351
|
+
}, z.core.$strict>;
|
|
352
|
+
contextPackage: z.ZodObject<{
|
|
353
|
+
mode: z.ZodEnum<{
|
|
354
|
+
author: "author";
|
|
355
|
+
existing: "existing";
|
|
356
|
+
none: "none";
|
|
357
|
+
}>;
|
|
358
|
+
contextPackageId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"ContextPackage ID">, string>>>;
|
|
359
|
+
}, z.core.$strict>;
|
|
360
|
+
delegation: z.ZodObject<{
|
|
361
|
+
fanOut: z.ZodEnum<{
|
|
362
|
+
bounded: "bounded";
|
|
363
|
+
none: "none";
|
|
364
|
+
}>;
|
|
365
|
+
maxChildren: z.ZodOptional<z.ZodNumber>;
|
|
366
|
+
promotion: z.ZodEnum<{
|
|
367
|
+
"auto-eligible": "auto-eligible";
|
|
368
|
+
"review-required": "review-required";
|
|
369
|
+
}>;
|
|
370
|
+
identity: z.ZodObject<{
|
|
371
|
+
servicePrincipalId: z.ZodString;
|
|
372
|
+
workspaceId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"workspace ID">, string>>;
|
|
373
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
374
|
+
}, z.core.$strict>;
|
|
375
|
+
childCeiling: z.ZodObject<{
|
|
376
|
+
runtimeDefinitionId: z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"runtime-definition ID">, string>>;
|
|
377
|
+
capabilityNames: z.ZodArray<z.ZodString>;
|
|
378
|
+
}, z.core.$strict>;
|
|
379
|
+
}, z.core.$strict>;
|
|
380
|
+
}, z.core.$strict>;
|
|
381
|
+
trace: z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
382
|
+
source: z.ZodEnum<{
|
|
383
|
+
"explicit-pin": "explicit-pin";
|
|
384
|
+
"policy-default": "policy-default";
|
|
385
|
+
"profile-default": "profile-default";
|
|
386
|
+
"project-default": "project-default";
|
|
387
|
+
}>;
|
|
388
|
+
value: z.ZodJSONSchema;
|
|
389
|
+
}, z.core.$strict>>;
|
|
390
|
+
diagnostics: z.ZodArray<z.ZodEnum<{
|
|
391
|
+
AUTO_MODE_EXPLICIT_PIN: "AUTO_MODE_EXPLICIT_PIN";
|
|
392
|
+
CAPABILITY_BEYOND_GRANT: "CAPABILITY_BEYOND_GRANT";
|
|
393
|
+
CONTEXT_PACKAGE_PIN_MISMATCH: "CONTEXT_PACKAGE_PIN_MISMATCH";
|
|
394
|
+
DELEGATION_BEYOND_POLICY: "DELEGATION_BEYOND_POLICY";
|
|
395
|
+
HARNESS_MAP_CONFLICTS_WITH_PIN: "HARNESS_MAP_CONFLICTS_WITH_PIN";
|
|
396
|
+
HARNESS_MAP_MODEL_ABSENT: "HARNESS_MAP_MODEL_ABSENT";
|
|
397
|
+
HARNESS_MAP_MODEL_UNMAPPED: "HARNESS_MAP_MODEL_UNMAPPED";
|
|
398
|
+
HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME: "HARNESS_UNAVAILABLE_ON_PINNED_RUNTIME";
|
|
399
|
+
MODEL_ACCESS_NOT_ENTITLED: "MODEL_ACCESS_NOT_ENTITLED";
|
|
400
|
+
NO_COMPATIBLE_RUNTIME: "NO_COMPATIBLE_RUNTIME";
|
|
401
|
+
NO_DEFAULT_MODEL: "NO_DEFAULT_MODEL";
|
|
402
|
+
SKILL_BEYOND_CAPABILITIES: "SKILL_BEYOND_CAPABILITIES";
|
|
403
|
+
SKILL_UNAVAILABLE: "SKILL_UNAVAILABLE";
|
|
404
|
+
UNSUPPORTED_RUNTIME_PIN: "UNSUPPORTED_RUNTIME_PIN";
|
|
405
|
+
}>>;
|
|
406
|
+
resolutionDigest: z.ZodString;
|
|
407
|
+
}, z.core.$strict>;
|
|
408
|
+
}, z.core.$strip>;
|
|
93
409
|
export declare const ProfileResolutionResponseSchema: z.ZodObject<{
|
|
94
410
|
contractVersion: typeof ContractVersionSchema;
|
|
95
411
|
requestId: typeof IdentifierSchemas.requestId;
|
|
@@ -267,38 +583,6 @@ export type CredentialGetRequest = z.input<typeof CredentialGetRequestSchema>;
|
|
|
267
583
|
export type CredentialListRequest = z.input<typeof CredentialListRequestSchema>;
|
|
268
584
|
export type CredentialResponse = z.output<typeof CredentialResponseSchema>;
|
|
269
585
|
export type CredentialListResponse = z.output<typeof CredentialListResponseSchema>;
|
|
270
|
-
declare const RuntimeNodeCredentialIdSchema: z.ZodString;
|
|
271
|
-
export declare const RuntimeNodeCredentialRevokeRequestSchema: z.ZodObject<{
|
|
272
|
-
caller: typeof ServiceCallerAssertionSchema;
|
|
273
|
-
contractVersion: typeof ContractVersionSchema;
|
|
274
|
-
requestId: typeof IdentifierSchemas.requestId;
|
|
275
|
-
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
276
|
-
correlation: typeof CorrelationMetadataSchema;
|
|
277
|
-
commandId: typeof IdentifierSchemas.commandId;
|
|
278
|
-
idempotencyKey: typeof IdempotencyKeySchema;
|
|
279
|
-
payloadHash: typeof PayloadHashSchema;
|
|
280
|
-
operation: z.ZodLiteral<"runtime-node-credential.revoke">;
|
|
281
|
-
issuedAt: typeof TimestampSchema;
|
|
282
|
-
payload: z.ZodObject<{
|
|
283
|
-
credentialId: z.ZodString;
|
|
284
|
-
}, z.core.$strict>;
|
|
285
|
-
}, z.core.$strict>;
|
|
286
|
-
export declare const RuntimeNodeCredentialRevocationResponseSchema: z.ZodObject<{
|
|
287
|
-
contractVersion: typeof ContractVersionSchema;
|
|
288
|
-
requestId: typeof IdentifierSchemas.requestId;
|
|
289
|
-
correlation: typeof CorrelationMetadataSchema;
|
|
290
|
-
data: z.ZodObject<{
|
|
291
|
-
credential: z.ZodObject<{
|
|
292
|
-
credentialId: typeof RuntimeNodeCredentialIdSchema;
|
|
293
|
-
nodeId: z.ZodString;
|
|
294
|
-
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
295
|
-
revocationVersion: z.ZodNumber;
|
|
296
|
-
revokedAt: typeof TimestampSchema;
|
|
297
|
-
}, z.core.$strict>;
|
|
298
|
-
}, z.core.$strict>;
|
|
299
|
-
}, z.core.$strip>;
|
|
300
|
-
export type RuntimeNodeCredentialRevokeRequest = z.input<typeof RuntimeNodeCredentialRevokeRequestSchema>;
|
|
301
|
-
export type RuntimeNodeCredentialRevocationResponse = z.output<typeof RuntimeNodeCredentialRevocationResponseSchema>;
|
|
302
586
|
export declare const ProjectStateResolutionRequestSchema: z.ZodObject<{
|
|
303
587
|
caller: typeof ServiceCallerAssertionSchema;
|
|
304
588
|
contractVersion: typeof ContractVersionSchema;
|
|
@@ -962,6 +1246,8 @@ export type InteractionResponseCommand = z.input<typeof InteractionResponseComma
|
|
|
962
1246
|
export type InteractionResponseCommandResult = z.output<typeof InteractionResponseCommandResultSchema>;
|
|
963
1247
|
export type ServiceAuthenticationRequest = z.input<typeof ServiceAuthenticationRequestSchema>;
|
|
964
1248
|
export type ServiceAuthenticationResponse = z.output<typeof ServiceAuthenticationResponseSchema>;
|
|
1249
|
+
export type DecisionResolveRequest = z.input<typeof DecisionResolveRequestSchema>;
|
|
1250
|
+
export type DecisionResolveResponse = z.output<typeof DecisionResolveResponseSchema>;
|
|
965
1251
|
export type ProfileResolutionRequest = z.input<typeof ProfileResolutionRequestSchema>;
|
|
966
1252
|
export type ProfileResolutionResponse = z.output<typeof ProfileResolutionResponseSchema>;
|
|
967
1253
|
export type ProjectStateResolutionRequest = z.input<typeof ProjectStateResolutionRequestSchema>;
|
|
@@ -1265,4 +1551,212 @@ export declare const CredentialApiFixtures: Readonly<{
|
|
|
1265
1551
|
};
|
|
1266
1552
|
};
|
|
1267
1553
|
}>;
|
|
1554
|
+
export declare const DeviceSyncUploadRequestSchema: z.ZodObject<{
|
|
1555
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1556
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1557
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1558
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1559
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1560
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1561
|
+
commandId: typeof IdentifierSchemas.commandId;
|
|
1562
|
+
idempotencyKey: typeof IdempotencyKeySchema;
|
|
1563
|
+
payloadHash: typeof PayloadHashSchema;
|
|
1564
|
+
operation: z.ZodLiteral<"device-sync.upload">;
|
|
1565
|
+
issuedAt: typeof TimestampSchema;
|
|
1566
|
+
payload: z.ZodObject<{
|
|
1567
|
+
objectId: z.ZodString;
|
|
1568
|
+
size: z.ZodNumber;
|
|
1569
|
+
ciphertextSha256: z.ZodString;
|
|
1570
|
+
authorKeyId: z.ZodString;
|
|
1571
|
+
}, z.core.$strict>;
|
|
1572
|
+
}, z.core.$strip>;
|
|
1573
|
+
export declare const DeviceSyncUploadResponseSchema: z.ZodObject<{
|
|
1574
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1575
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1576
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1577
|
+
data: z.ZodObject<{
|
|
1578
|
+
objectId: z.ZodString;
|
|
1579
|
+
url: z.ZodURL;
|
|
1580
|
+
headers: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
1581
|
+
expiresAt: z.ZodISODateTime;
|
|
1582
|
+
}, z.core.$strict>;
|
|
1583
|
+
}, z.core.$strip>;
|
|
1584
|
+
export declare const DeviceSyncCommitRequestSchema: z.ZodObject<{
|
|
1585
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1586
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1587
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1588
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1589
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1590
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1591
|
+
commandId: typeof IdentifierSchemas.commandId;
|
|
1592
|
+
idempotencyKey: typeof IdempotencyKeySchema;
|
|
1593
|
+
payloadHash: typeof PayloadHashSchema;
|
|
1594
|
+
operation: z.ZodLiteral<"device-sync.commit">;
|
|
1595
|
+
issuedAt: typeof TimestampSchema;
|
|
1596
|
+
payload: z.ZodObject<{
|
|
1597
|
+
objectId: z.ZodString;
|
|
1598
|
+
}, z.core.$strict>;
|
|
1599
|
+
}, z.core.$strip>;
|
|
1600
|
+
export declare const DeviceSyncCommitResponseSchema: z.ZodObject<{
|
|
1601
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1602
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1603
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1604
|
+
data: z.ZodObject<{
|
|
1605
|
+
objectId: z.ZodString;
|
|
1606
|
+
size: z.ZodNumber;
|
|
1607
|
+
}, z.core.$strict>;
|
|
1608
|
+
}, z.core.$strip>;
|
|
1609
|
+
export declare const DeviceSyncDownloadRequestSchema: z.ZodObject<{
|
|
1610
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1611
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1612
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1613
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1614
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1615
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1616
|
+
operation: z.ZodLiteral<"device-sync.download">;
|
|
1617
|
+
requestedAt: typeof TimestampSchema;
|
|
1618
|
+
parameters: z.ZodObject<{
|
|
1619
|
+
objectIds: z.ZodArray<z.ZodString>;
|
|
1620
|
+
}, z.core.$strict>;
|
|
1621
|
+
}, z.core.$strip>;
|
|
1622
|
+
export declare const DeviceSyncDownloadResponseSchema: z.ZodObject<{
|
|
1623
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1624
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1625
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1626
|
+
data: z.ZodObject<{
|
|
1627
|
+
downloads: z.ZodArray<z.ZodObject<{
|
|
1628
|
+
objectId: z.ZodString;
|
|
1629
|
+
url: z.ZodURL;
|
|
1630
|
+
size: z.ZodNumber;
|
|
1631
|
+
}, z.core.$strict>>;
|
|
1632
|
+
missing: z.ZodArray<z.ZodString>;
|
|
1633
|
+
expiresAt: z.ZodISODateTime;
|
|
1634
|
+
}, z.core.$strict>;
|
|
1635
|
+
}, z.core.$strip>;
|
|
1636
|
+
export declare const DeviceSyncReleaseRequestSchema: z.ZodObject<{
|
|
1637
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1638
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1639
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1640
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1641
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1642
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1643
|
+
commandId: typeof IdentifierSchemas.commandId;
|
|
1644
|
+
idempotencyKey: typeof IdempotencyKeySchema;
|
|
1645
|
+
payloadHash: typeof PayloadHashSchema;
|
|
1646
|
+
operation: z.ZodLiteral<"device-sync.release">;
|
|
1647
|
+
issuedAt: typeof TimestampSchema;
|
|
1648
|
+
payload: z.ZodObject<{
|
|
1649
|
+
objectIds: z.ZodArray<z.ZodString>;
|
|
1650
|
+
}, z.core.$strict>;
|
|
1651
|
+
}, z.core.$strip>;
|
|
1652
|
+
export declare const DeviceSyncReleaseResponseSchema: z.ZodObject<{
|
|
1653
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1654
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1655
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1656
|
+
data: z.ZodObject<{
|
|
1657
|
+
released: z.ZodNumber;
|
|
1658
|
+
}, z.core.$strict>;
|
|
1659
|
+
}, z.core.$strip>;
|
|
1660
|
+
export declare const DeviceSyncAppendRequestSchema: z.ZodObject<{
|
|
1661
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1662
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1663
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1664
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1665
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1666
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1667
|
+
commandId: typeof IdentifierSchemas.commandId;
|
|
1668
|
+
idempotencyKey: typeof IdempotencyKeySchema;
|
|
1669
|
+
payloadHash: typeof PayloadHashSchema;
|
|
1670
|
+
operation: z.ZodLiteral<"device-sync.append">;
|
|
1671
|
+
issuedAt: typeof TimestampSchema;
|
|
1672
|
+
payload: z.ZodObject<{
|
|
1673
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
1674
|
+
entryId: z.ZodString;
|
|
1675
|
+
authorKeyId: z.ZodString;
|
|
1676
|
+
objectIds: z.ZodArray<z.ZodString>;
|
|
1677
|
+
ckv: z.ZodNumber;
|
|
1678
|
+
nonce: z.ZodString;
|
|
1679
|
+
ciphertext: z.ZodString;
|
|
1680
|
+
signature: z.ZodString;
|
|
1681
|
+
}, z.core.$strict>>;
|
|
1682
|
+
}, z.core.$strict>;
|
|
1683
|
+
}, z.core.$strip>;
|
|
1684
|
+
export declare const DeviceSyncAppendResponseSchema: z.ZodObject<{
|
|
1685
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1686
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1687
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1688
|
+
data: z.ZodObject<{
|
|
1689
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
1690
|
+
entryId: z.ZodString;
|
|
1691
|
+
seq: z.ZodNumber;
|
|
1692
|
+
}, z.core.$strict>>;
|
|
1693
|
+
}, z.core.$strict>;
|
|
1694
|
+
}, z.core.$strip>;
|
|
1695
|
+
export declare const DeviceSyncLogRequestSchema: z.ZodObject<{
|
|
1696
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1697
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1698
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1699
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1700
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1701
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1702
|
+
operation: z.ZodLiteral<"device-sync.log">;
|
|
1703
|
+
requestedAt: typeof TimestampSchema;
|
|
1704
|
+
parameters: z.ZodObject<{
|
|
1705
|
+
afterSeq: z.ZodNumber;
|
|
1706
|
+
limit: z.ZodOptional<z.ZodNumber>;
|
|
1707
|
+
}, z.core.$strict>;
|
|
1708
|
+
}, z.core.$strip>;
|
|
1709
|
+
export declare const DeviceSyncLogResponseSchema: z.ZodObject<{
|
|
1710
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1711
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1712
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1713
|
+
data: z.ZodObject<{
|
|
1714
|
+
entries: z.ZodArray<z.ZodObject<{
|
|
1715
|
+
entryId: z.ZodString;
|
|
1716
|
+
authorKeyId: z.ZodString;
|
|
1717
|
+
objectIds: z.ZodArray<z.ZodString>;
|
|
1718
|
+
ckv: z.ZodNumber;
|
|
1719
|
+
nonce: z.ZodString;
|
|
1720
|
+
ciphertext: z.ZodString;
|
|
1721
|
+
signature: z.ZodString;
|
|
1722
|
+
seq: z.ZodNumber;
|
|
1723
|
+
createdAt: z.ZodISODateTime;
|
|
1724
|
+
}, z.core.$strict>>;
|
|
1725
|
+
headSeq: z.ZodNumber;
|
|
1726
|
+
}, z.core.$strict>;
|
|
1727
|
+
}, z.core.$strip>;
|
|
1728
|
+
export declare const DeviceSyncUsageRequestSchema: z.ZodObject<{
|
|
1729
|
+
caller: typeof ServiceCallerAssertionSchema;
|
|
1730
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1731
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1732
|
+
workspaceId: typeof IdentifierSchemas.workspaceId;
|
|
1733
|
+
projectId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<import("./identifiers.js").OpaqueIdentifier<"project ID">, string>>>;
|
|
1734
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1735
|
+
operation: z.ZodLiteral<"device-sync.usage">;
|
|
1736
|
+
requestedAt: typeof TimestampSchema;
|
|
1737
|
+
parameters: z.ZodObject<{}, z.core.$strict>;
|
|
1738
|
+
}, z.core.$strip>;
|
|
1739
|
+
export declare const DeviceSyncUsageResponseSchema: z.ZodObject<{
|
|
1740
|
+
contractVersion: typeof ContractVersionSchema;
|
|
1741
|
+
requestId: typeof IdentifierSchemas.requestId;
|
|
1742
|
+
correlation: typeof CorrelationMetadataSchema;
|
|
1743
|
+
data: z.ZodObject<{
|
|
1744
|
+
usedBytes: z.ZodNumber;
|
|
1745
|
+
quotaBytes: z.ZodNumber;
|
|
1746
|
+
}, z.core.$strict>;
|
|
1747
|
+
}, z.core.$strip>;
|
|
1748
|
+
export type DeviceSyncUploadRequest = z.input<typeof DeviceSyncUploadRequestSchema>;
|
|
1749
|
+
export type DeviceSyncUploadResponse = z.output<typeof DeviceSyncUploadResponseSchema>;
|
|
1750
|
+
export type DeviceSyncCommitRequest = z.input<typeof DeviceSyncCommitRequestSchema>;
|
|
1751
|
+
export type DeviceSyncCommitResponse = z.output<typeof DeviceSyncCommitResponseSchema>;
|
|
1752
|
+
export type DeviceSyncDownloadRequest = z.input<typeof DeviceSyncDownloadRequestSchema>;
|
|
1753
|
+
export type DeviceSyncDownloadResponse = z.output<typeof DeviceSyncDownloadResponseSchema>;
|
|
1754
|
+
export type DeviceSyncReleaseRequest = z.input<typeof DeviceSyncReleaseRequestSchema>;
|
|
1755
|
+
export type DeviceSyncReleaseResponse = z.output<typeof DeviceSyncReleaseResponseSchema>;
|
|
1756
|
+
export type DeviceSyncAppendRequest = z.input<typeof DeviceSyncAppendRequestSchema>;
|
|
1757
|
+
export type DeviceSyncAppendResponse = z.output<typeof DeviceSyncAppendResponseSchema>;
|
|
1758
|
+
export type DeviceSyncLogRequest = z.input<typeof DeviceSyncLogRequestSchema>;
|
|
1759
|
+
export type DeviceSyncLogResponse = z.output<typeof DeviceSyncLogResponseSchema>;
|
|
1760
|
+
export type DeviceSyncUsageRequest = z.input<typeof DeviceSyncUsageRequestSchema>;
|
|
1761
|
+
export type DeviceSyncUsageResponse = z.output<typeof DeviceSyncUsageResponseSchema>;
|
|
1268
1762
|
export {};
|