@lucern/mcp 0.2.0-alpha.1 → 0.2.0-alpha.10
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/gateway.d.ts +769 -0
- package/dist/gateway.js +10054 -0
- package/dist/gateway.js.map +1 -0
- package/dist/index.d.ts +307 -0
- package/dist/index.js +3430 -1376
- package/dist/index.js.map +1 -1
- package/dist/runtime.d.ts +111 -0
- package/dist/runtime.js +2915 -0
- package/dist/runtime.js.map +1 -0
- package/package.json +16 -2
|
@@ -0,0 +1,769 @@
|
|
|
1
|
+
import { GatewayAuthContext } from '@lucern/contracts';
|
|
2
|
+
export { GatewayContextAuth, GatewayContextRequest, GatewayContextRouteDeps, createContextGatewayRoute } from '@lucern/server-core/http';
|
|
3
|
+
|
|
4
|
+
declare function handleBeliefCreate(args: {
|
|
5
|
+
authContext: GatewayAuthContext;
|
|
6
|
+
correlationId: string;
|
|
7
|
+
policyTraceId: string;
|
|
8
|
+
body: unknown;
|
|
9
|
+
}): Promise<Response>;
|
|
10
|
+
declare function handleBeliefGet(args: {
|
|
11
|
+
authContext: GatewayAuthContext;
|
|
12
|
+
correlationId: string;
|
|
13
|
+
policyTraceId: string;
|
|
14
|
+
beliefId: string;
|
|
15
|
+
}): Promise<Response>;
|
|
16
|
+
declare function handleBeliefList(args: {
|
|
17
|
+
authContext: GatewayAuthContext;
|
|
18
|
+
correlationId: string;
|
|
19
|
+
policyTraceId: string;
|
|
20
|
+
query: {
|
|
21
|
+
topicId?: string;
|
|
22
|
+
status?: string;
|
|
23
|
+
worktreeId?: string;
|
|
24
|
+
minConfidence?: number;
|
|
25
|
+
limit?: number;
|
|
26
|
+
cursor?: string;
|
|
27
|
+
};
|
|
28
|
+
}): Promise<Response>;
|
|
29
|
+
declare function handleBeliefRefine(args: {
|
|
30
|
+
authContext: GatewayAuthContext;
|
|
31
|
+
correlationId: string;
|
|
32
|
+
policyTraceId: string;
|
|
33
|
+
beliefId: string;
|
|
34
|
+
body: unknown;
|
|
35
|
+
}): Promise<Response>;
|
|
36
|
+
declare function handleBeliefFork(args: {
|
|
37
|
+
authContext: GatewayAuthContext;
|
|
38
|
+
correlationId: string;
|
|
39
|
+
policyTraceId: string;
|
|
40
|
+
beliefId: string;
|
|
41
|
+
body: unknown;
|
|
42
|
+
}): Promise<Response>;
|
|
43
|
+
declare function handleBeliefUpdateConfidence(args: {
|
|
44
|
+
authContext: GatewayAuthContext;
|
|
45
|
+
correlationId: string;
|
|
46
|
+
policyTraceId: string;
|
|
47
|
+
beliefId: string;
|
|
48
|
+
body: unknown;
|
|
49
|
+
}): Promise<Response>;
|
|
50
|
+
declare function handleBeliefUpdateStatus(args: {
|
|
51
|
+
authContext: GatewayAuthContext;
|
|
52
|
+
correlationId: string;
|
|
53
|
+
policyTraceId: string;
|
|
54
|
+
body: unknown;
|
|
55
|
+
}): Promise<Response>;
|
|
56
|
+
declare function handleBeliefUpdateRationale(args: {
|
|
57
|
+
authContext: GatewayAuthContext;
|
|
58
|
+
correlationId: string;
|
|
59
|
+
policyTraceId: string;
|
|
60
|
+
body: unknown;
|
|
61
|
+
}): Promise<Response>;
|
|
62
|
+
declare function handleBeliefLink(args: {
|
|
63
|
+
authContext: GatewayAuthContext;
|
|
64
|
+
correlationId: string;
|
|
65
|
+
policyTraceId: string;
|
|
66
|
+
body: unknown;
|
|
67
|
+
}): Promise<Response>;
|
|
68
|
+
declare function handleBeliefUnlinkEvidence(args: {
|
|
69
|
+
authContext: GatewayAuthContext;
|
|
70
|
+
correlationId: string;
|
|
71
|
+
policyTraceId: string;
|
|
72
|
+
body: unknown;
|
|
73
|
+
}): Promise<Response>;
|
|
74
|
+
declare function handleBeliefUpdateCriticality(args: {
|
|
75
|
+
authContext: GatewayAuthContext;
|
|
76
|
+
correlationId: string;
|
|
77
|
+
policyTraceId: string;
|
|
78
|
+
body: unknown;
|
|
79
|
+
}): Promise<Response>;
|
|
80
|
+
declare function handleBeliefBatchUpdateCriticality(args: {
|
|
81
|
+
authContext: GatewayAuthContext;
|
|
82
|
+
correlationId: string;
|
|
83
|
+
policyTraceId: string;
|
|
84
|
+
body: unknown;
|
|
85
|
+
}): Promise<Response>;
|
|
86
|
+
declare function handleBeliefReassignTopic(args: {
|
|
87
|
+
authContext: GatewayAuthContext;
|
|
88
|
+
correlationId: string;
|
|
89
|
+
policyTraceId: string;
|
|
90
|
+
body: unknown;
|
|
91
|
+
}): Promise<Response>;
|
|
92
|
+
declare function handleBeliefArchive(args: {
|
|
93
|
+
authContext: GatewayAuthContext;
|
|
94
|
+
correlationId: string;
|
|
95
|
+
policyTraceId: string;
|
|
96
|
+
beliefId: string;
|
|
97
|
+
body: unknown;
|
|
98
|
+
}): Promise<Response>;
|
|
99
|
+
declare function handleBeliefLineage(args: {
|
|
100
|
+
authContext: GatewayAuthContext;
|
|
101
|
+
correlationId: string;
|
|
102
|
+
policyTraceId: string;
|
|
103
|
+
beliefId: string;
|
|
104
|
+
}): Promise<Response>;
|
|
105
|
+
declare function handleBeliefConfidenceHistory(args: {
|
|
106
|
+
authContext: GatewayAuthContext;
|
|
107
|
+
correlationId: string;
|
|
108
|
+
policyTraceId: string;
|
|
109
|
+
beliefId: string;
|
|
110
|
+
}): Promise<Response>;
|
|
111
|
+
declare function handleBeliefRelationships(args: {
|
|
112
|
+
authContext: GatewayAuthContext;
|
|
113
|
+
correlationId: string;
|
|
114
|
+
policyTraceId: string;
|
|
115
|
+
beliefId: string;
|
|
116
|
+
direction?: string;
|
|
117
|
+
}): Promise<Response>;
|
|
118
|
+
declare function handleBeliefCreateContract(args: {
|
|
119
|
+
authContext: GatewayAuthContext;
|
|
120
|
+
correlationId: string;
|
|
121
|
+
policyTraceId: string;
|
|
122
|
+
beliefId: string;
|
|
123
|
+
body: unknown;
|
|
124
|
+
}): Promise<Response>;
|
|
125
|
+
declare function handleBeliefBisect(args: {
|
|
126
|
+
authContext: GatewayAuthContext;
|
|
127
|
+
correlationId: string;
|
|
128
|
+
policyTraceId: string;
|
|
129
|
+
beliefId: string;
|
|
130
|
+
body: unknown;
|
|
131
|
+
}): Promise<Response>;
|
|
132
|
+
|
|
133
|
+
declare function handleContradictionFlag(args: {
|
|
134
|
+
authContext: GatewayAuthContext;
|
|
135
|
+
correlationId: string;
|
|
136
|
+
policyTraceId: string;
|
|
137
|
+
body: unknown;
|
|
138
|
+
}): Promise<Response>;
|
|
139
|
+
declare function handleContradictionList(args: {
|
|
140
|
+
authContext: GatewayAuthContext;
|
|
141
|
+
correlationId: string;
|
|
142
|
+
policyTraceId: string;
|
|
143
|
+
query: {
|
|
144
|
+
topicId?: string;
|
|
145
|
+
status?: string;
|
|
146
|
+
limit?: number;
|
|
147
|
+
cursor?: string;
|
|
148
|
+
};
|
|
149
|
+
}): Promise<Response>;
|
|
150
|
+
declare function handleContradictionGet(args: {
|
|
151
|
+
authContext: GatewayAuthContext;
|
|
152
|
+
correlationId: string;
|
|
153
|
+
policyTraceId: string;
|
|
154
|
+
contradictionId: string;
|
|
155
|
+
}): Promise<Response>;
|
|
156
|
+
|
|
157
|
+
declare function handleEdgeCreate(args: {
|
|
158
|
+
authContext: GatewayAuthContext;
|
|
159
|
+
correlationId: string;
|
|
160
|
+
policyTraceId: string;
|
|
161
|
+
body: unknown;
|
|
162
|
+
}): Promise<Response>;
|
|
163
|
+
declare function handleEdgeList(args: {
|
|
164
|
+
authContext: GatewayAuthContext;
|
|
165
|
+
correlationId: string;
|
|
166
|
+
policyTraceId: string;
|
|
167
|
+
query: {
|
|
168
|
+
sourceId?: string;
|
|
169
|
+
edgeType?: string;
|
|
170
|
+
limit?: number;
|
|
171
|
+
cursor?: string;
|
|
172
|
+
};
|
|
173
|
+
}): Promise<Response>;
|
|
174
|
+
declare function handleEdgeTraverse(args: {
|
|
175
|
+
authContext: GatewayAuthContext;
|
|
176
|
+
correlationId: string;
|
|
177
|
+
policyTraceId: string;
|
|
178
|
+
body: unknown;
|
|
179
|
+
}): Promise<Response>;
|
|
180
|
+
declare function handleEdgeUpdate(args: {
|
|
181
|
+
authContext: GatewayAuthContext;
|
|
182
|
+
correlationId: string;
|
|
183
|
+
policyTraceId: string;
|
|
184
|
+
body: unknown;
|
|
185
|
+
}): Promise<Response>;
|
|
186
|
+
declare function handleEdgeRemove(args: {
|
|
187
|
+
authContext: GatewayAuthContext;
|
|
188
|
+
correlationId: string;
|
|
189
|
+
policyTraceId: string;
|
|
190
|
+
body: unknown;
|
|
191
|
+
}): Promise<Response>;
|
|
192
|
+
declare function handleEdgesRemoveBetween(args: {
|
|
193
|
+
authContext: GatewayAuthContext;
|
|
194
|
+
correlationId: string;
|
|
195
|
+
policyTraceId: string;
|
|
196
|
+
body: unknown;
|
|
197
|
+
}): Promise<Response>;
|
|
198
|
+
declare function handleEdgeBatchCreate(args: {
|
|
199
|
+
authContext: GatewayAuthContext;
|
|
200
|
+
correlationId: string;
|
|
201
|
+
policyTraceId: string;
|
|
202
|
+
body: unknown;
|
|
203
|
+
}): Promise<Response>;
|
|
204
|
+
declare function handleEdgeDelete(args: {
|
|
205
|
+
authContext: GatewayAuthContext;
|
|
206
|
+
correlationId: string;
|
|
207
|
+
policyTraceId: string;
|
|
208
|
+
body: unknown;
|
|
209
|
+
}): Promise<Response>;
|
|
210
|
+
|
|
211
|
+
declare function handleEventsList(args: {
|
|
212
|
+
authContext: GatewayAuthContext;
|
|
213
|
+
correlationId: string;
|
|
214
|
+
policyTraceId: string;
|
|
215
|
+
query: {
|
|
216
|
+
topicId?: string;
|
|
217
|
+
after?: string;
|
|
218
|
+
types?: string[];
|
|
219
|
+
startTime?: number;
|
|
220
|
+
endTime?: number;
|
|
221
|
+
limit?: number;
|
|
222
|
+
};
|
|
223
|
+
}): Promise<Response>;
|
|
224
|
+
declare function handleEventsReplay(args: {
|
|
225
|
+
authContext: GatewayAuthContext;
|
|
226
|
+
correlationId: string;
|
|
227
|
+
policyTraceId: string;
|
|
228
|
+
body: {
|
|
229
|
+
topicId?: string;
|
|
230
|
+
webhookId?: string;
|
|
231
|
+
after?: string;
|
|
232
|
+
types?: string[];
|
|
233
|
+
startTime?: number;
|
|
234
|
+
endTime?: number;
|
|
235
|
+
limit?: number;
|
|
236
|
+
};
|
|
237
|
+
}): Promise<Response>;
|
|
238
|
+
|
|
239
|
+
declare function handleEvidenceCreate(args: {
|
|
240
|
+
authContext: GatewayAuthContext;
|
|
241
|
+
correlationId: string;
|
|
242
|
+
policyTraceId: string;
|
|
243
|
+
body: unknown;
|
|
244
|
+
}): Promise<Response>;
|
|
245
|
+
declare function handleEvidenceGet(args: {
|
|
246
|
+
authContext: GatewayAuthContext;
|
|
247
|
+
correlationId: string;
|
|
248
|
+
policyTraceId: string;
|
|
249
|
+
evidenceId: string;
|
|
250
|
+
}): Promise<Response>;
|
|
251
|
+
declare function handleEvidenceList(args: {
|
|
252
|
+
authContext: GatewayAuthContext;
|
|
253
|
+
correlationId: string;
|
|
254
|
+
policyTraceId: string;
|
|
255
|
+
query: {
|
|
256
|
+
topicId?: string;
|
|
257
|
+
targetId?: string;
|
|
258
|
+
limit?: number;
|
|
259
|
+
cursor?: string;
|
|
260
|
+
};
|
|
261
|
+
}): Promise<Response>;
|
|
262
|
+
declare function handleEvidenceLink(args: {
|
|
263
|
+
authContext: GatewayAuthContext;
|
|
264
|
+
correlationId: string;
|
|
265
|
+
policyTraceId: string;
|
|
266
|
+
evidenceId: string;
|
|
267
|
+
body: unknown;
|
|
268
|
+
}): Promise<Response>;
|
|
269
|
+
declare function handleEvidenceSearch(args: {
|
|
270
|
+
authContext: GatewayAuthContext;
|
|
271
|
+
correlationId: string;
|
|
272
|
+
policyTraceId: string;
|
|
273
|
+
body: unknown;
|
|
274
|
+
}): Promise<Response>;
|
|
275
|
+
declare function handleEvidenceClassify(args: {
|
|
276
|
+
authContext: GatewayAuthContext;
|
|
277
|
+
correlationId: string;
|
|
278
|
+
policyTraceId: string;
|
|
279
|
+
body: unknown;
|
|
280
|
+
}): Promise<Response>;
|
|
281
|
+
declare function handleEvidenceClassifyBatch(args: {
|
|
282
|
+
authContext: GatewayAuthContext;
|
|
283
|
+
correlationId: string;
|
|
284
|
+
policyTraceId: string;
|
|
285
|
+
body: unknown;
|
|
286
|
+
}): Promise<Response>;
|
|
287
|
+
declare function handleEvidenceUpdateStatus(args: {
|
|
288
|
+
authContext: GatewayAuthContext;
|
|
289
|
+
correlationId: string;
|
|
290
|
+
policyTraceId: string;
|
|
291
|
+
body: unknown;
|
|
292
|
+
}): Promise<Response>;
|
|
293
|
+
declare function handleEvidenceUpdate(args: {
|
|
294
|
+
authContext: GatewayAuthContext;
|
|
295
|
+
correlationId: string;
|
|
296
|
+
policyTraceId: string;
|
|
297
|
+
body: unknown;
|
|
298
|
+
}): Promise<Response>;
|
|
299
|
+
declare function handleEvidenceFlagIncorrect(args: {
|
|
300
|
+
authContext: GatewayAuthContext;
|
|
301
|
+
correlationId: string;
|
|
302
|
+
policyTraceId: string;
|
|
303
|
+
body: unknown;
|
|
304
|
+
}): Promise<Response>;
|
|
305
|
+
declare function handleEvidenceRemove(args: {
|
|
306
|
+
authContext: GatewayAuthContext;
|
|
307
|
+
correlationId: string;
|
|
308
|
+
policyTraceId: string;
|
|
309
|
+
body: unknown;
|
|
310
|
+
}): Promise<Response>;
|
|
311
|
+
declare function handleEvidenceUpdateVerificationStatus(args: {
|
|
312
|
+
authContext: GatewayAuthContext;
|
|
313
|
+
correlationId: string;
|
|
314
|
+
policyTraceId: string;
|
|
315
|
+
body: unknown;
|
|
316
|
+
}): Promise<Response>;
|
|
317
|
+
|
|
318
|
+
declare function handleGraphNeighborhood(args: {
|
|
319
|
+
authContext: GatewayAuthContext;
|
|
320
|
+
correlationId: string;
|
|
321
|
+
policyTraceId: string;
|
|
322
|
+
query: {
|
|
323
|
+
globalId?: string;
|
|
324
|
+
globalIds?: string[];
|
|
325
|
+
maxDepth?: number;
|
|
326
|
+
};
|
|
327
|
+
}): Promise<Response>;
|
|
328
|
+
declare function handleGraphTraverse(args: {
|
|
329
|
+
authContext: GatewayAuthContext;
|
|
330
|
+
correlationId: string;
|
|
331
|
+
policyTraceId: string;
|
|
332
|
+
body: unknown;
|
|
333
|
+
}): Promise<Response>;
|
|
334
|
+
declare function handleGraphAnalyze(args: {
|
|
335
|
+
authContext: GatewayAuthContext;
|
|
336
|
+
correlationId: string;
|
|
337
|
+
policyTraceId: string;
|
|
338
|
+
query: {
|
|
339
|
+
topicId?: string;
|
|
340
|
+
metric?: string;
|
|
341
|
+
limit?: number;
|
|
342
|
+
};
|
|
343
|
+
}): Promise<Response>;
|
|
344
|
+
declare function handleGraphBias(args: {
|
|
345
|
+
authContext: GatewayAuthContext;
|
|
346
|
+
correlationId: string;
|
|
347
|
+
policyTraceId: string;
|
|
348
|
+
query: {
|
|
349
|
+
topicId?: string;
|
|
350
|
+
threshold?: number;
|
|
351
|
+
limit?: number;
|
|
352
|
+
};
|
|
353
|
+
}): Promise<Response>;
|
|
354
|
+
declare function handleGraphGaps(args: {
|
|
355
|
+
authContext: GatewayAuthContext;
|
|
356
|
+
correlationId: string;
|
|
357
|
+
policyTraceId: string;
|
|
358
|
+
query: {
|
|
359
|
+
topicId?: string;
|
|
360
|
+
minConfidence?: number;
|
|
361
|
+
};
|
|
362
|
+
}): Promise<Response>;
|
|
363
|
+
declare function handleGraphFalsify(args: {
|
|
364
|
+
authContext: GatewayAuthContext;
|
|
365
|
+
correlationId: string;
|
|
366
|
+
policyTraceId: string;
|
|
367
|
+
body: unknown;
|
|
368
|
+
}): Promise<Response>;
|
|
369
|
+
|
|
370
|
+
declare function handleIdentityWhoami(args: {
|
|
371
|
+
authContext: GatewayAuthContext;
|
|
372
|
+
correlationId: string;
|
|
373
|
+
policyTraceId: string;
|
|
374
|
+
}): Promise<Response>;
|
|
375
|
+
|
|
376
|
+
declare function handleOntologyList(args: {
|
|
377
|
+
authContext: GatewayAuthContext;
|
|
378
|
+
correlationId: string;
|
|
379
|
+
policyTraceId: string;
|
|
380
|
+
query: {
|
|
381
|
+
tenantId?: string;
|
|
382
|
+
tier?: string;
|
|
383
|
+
status?: string;
|
|
384
|
+
};
|
|
385
|
+
}): Promise<Response>;
|
|
386
|
+
declare function handleOntologyGet(args: {
|
|
387
|
+
authContext: GatewayAuthContext;
|
|
388
|
+
correlationId: string;
|
|
389
|
+
policyTraceId: string;
|
|
390
|
+
ontologyId: string;
|
|
391
|
+
}): Promise<Response>;
|
|
392
|
+
declare function handleOntologyBind(args: {
|
|
393
|
+
authContext: GatewayAuthContext;
|
|
394
|
+
correlationId: string;
|
|
395
|
+
policyTraceId: string;
|
|
396
|
+
ontologyId: string;
|
|
397
|
+
body: unknown;
|
|
398
|
+
}): Promise<Response>;
|
|
399
|
+
declare function handleOntologyMatch(args: {
|
|
400
|
+
authContext: GatewayAuthContext;
|
|
401
|
+
correlationId: string;
|
|
402
|
+
policyTraceId: string;
|
|
403
|
+
body: unknown;
|
|
404
|
+
}): Promise<Response>;
|
|
405
|
+
|
|
406
|
+
declare function handleQuestionCreate(args: {
|
|
407
|
+
authContext: GatewayAuthContext;
|
|
408
|
+
correlationId: string;
|
|
409
|
+
policyTraceId: string;
|
|
410
|
+
body: unknown;
|
|
411
|
+
}): Promise<Response>;
|
|
412
|
+
declare function handleQuestionGet(args: {
|
|
413
|
+
authContext: GatewayAuthContext;
|
|
414
|
+
correlationId: string;
|
|
415
|
+
policyTraceId: string;
|
|
416
|
+
questionId: string;
|
|
417
|
+
}): Promise<Response>;
|
|
418
|
+
declare function handleQuestionArchive(args: {
|
|
419
|
+
authContext: GatewayAuthContext;
|
|
420
|
+
correlationId: string;
|
|
421
|
+
policyTraceId: string;
|
|
422
|
+
questionId: string;
|
|
423
|
+
body: unknown;
|
|
424
|
+
}): Promise<Response>;
|
|
425
|
+
declare function handleQuestionList(args: {
|
|
426
|
+
authContext: GatewayAuthContext;
|
|
427
|
+
correlationId: string;
|
|
428
|
+
policyTraceId: string;
|
|
429
|
+
query: {
|
|
430
|
+
topicId?: string;
|
|
431
|
+
status?: string;
|
|
432
|
+
priority?: string;
|
|
433
|
+
worktreeId?: string;
|
|
434
|
+
limit?: number;
|
|
435
|
+
cursor?: string;
|
|
436
|
+
};
|
|
437
|
+
}): Promise<Response>;
|
|
438
|
+
declare function handleQuestionAnswer(args: {
|
|
439
|
+
authContext: GatewayAuthContext;
|
|
440
|
+
correlationId: string;
|
|
441
|
+
policyTraceId: string;
|
|
442
|
+
questionId: string;
|
|
443
|
+
body: unknown;
|
|
444
|
+
}): Promise<Response>;
|
|
445
|
+
declare function handleQuestionGetAnswer(args: {
|
|
446
|
+
authContext: GatewayAuthContext;
|
|
447
|
+
correlationId: string;
|
|
448
|
+
policyTraceId: string;
|
|
449
|
+
questionId: string;
|
|
450
|
+
}): Promise<Response>;
|
|
451
|
+
declare function handleQuestionRefine(args: {
|
|
452
|
+
authContext: GatewayAuthContext;
|
|
453
|
+
correlationId: string;
|
|
454
|
+
policyTraceId: string;
|
|
455
|
+
questionId: string;
|
|
456
|
+
body: unknown;
|
|
457
|
+
}): Promise<Response>;
|
|
458
|
+
declare function handleQuestionUpdateStatus(args: {
|
|
459
|
+
authContext: GatewayAuthContext;
|
|
460
|
+
correlationId: string;
|
|
461
|
+
policyTraceId: string;
|
|
462
|
+
questionId: string;
|
|
463
|
+
body: unknown;
|
|
464
|
+
}): Promise<Response>;
|
|
465
|
+
declare function handleQuestionBatchCreate(args: {
|
|
466
|
+
authContext: GatewayAuthContext;
|
|
467
|
+
correlationId: string;
|
|
468
|
+
policyTraceId: string;
|
|
469
|
+
body: unknown;
|
|
470
|
+
}): Promise<Response>;
|
|
471
|
+
declare function handleQuestionAdd(args: {
|
|
472
|
+
authContext: GatewayAuthContext;
|
|
473
|
+
correlationId: string;
|
|
474
|
+
policyTraceId: string;
|
|
475
|
+
body: unknown;
|
|
476
|
+
}): Promise<Response>;
|
|
477
|
+
declare function handleQuestionUpdatePriority(args: {
|
|
478
|
+
authContext: GatewayAuthContext;
|
|
479
|
+
correlationId: string;
|
|
480
|
+
policyTraceId: string;
|
|
481
|
+
body: unknown;
|
|
482
|
+
}): Promise<Response>;
|
|
483
|
+
declare function handleQuestionAdvanceToConviction(args: {
|
|
484
|
+
authContext: GatewayAuthContext;
|
|
485
|
+
correlationId: string;
|
|
486
|
+
policyTraceId: string;
|
|
487
|
+
body: unknown;
|
|
488
|
+
}): Promise<Response>;
|
|
489
|
+
declare function handleQuestionUpdateConviction(args: {
|
|
490
|
+
authContext: GatewayAuthContext;
|
|
491
|
+
correlationId: string;
|
|
492
|
+
policyTraceId: string;
|
|
493
|
+
body: unknown;
|
|
494
|
+
}): Promise<Response>;
|
|
495
|
+
declare function handleQuestionFinalizeConviction(args: {
|
|
496
|
+
authContext: GatewayAuthContext;
|
|
497
|
+
correlationId: string;
|
|
498
|
+
policyTraceId: string;
|
|
499
|
+
body: unknown;
|
|
500
|
+
}): Promise<Response>;
|
|
501
|
+
declare function handleQuestionUpdate(args: {
|
|
502
|
+
authContext: GatewayAuthContext;
|
|
503
|
+
correlationId: string;
|
|
504
|
+
policyTraceId: string;
|
|
505
|
+
body: unknown;
|
|
506
|
+
}): Promise<Response>;
|
|
507
|
+
declare function handleQuestionDelete(args: {
|
|
508
|
+
authContext: GatewayAuthContext;
|
|
509
|
+
correlationId: string;
|
|
510
|
+
policyTraceId: string;
|
|
511
|
+
body: unknown;
|
|
512
|
+
}): Promise<Response>;
|
|
513
|
+
|
|
514
|
+
declare function handleSearchResources(args: {
|
|
515
|
+
authContext: GatewayAuthContext;
|
|
516
|
+
correlationId: string;
|
|
517
|
+
policyTraceId: string;
|
|
518
|
+
body: unknown;
|
|
519
|
+
}): Promise<Response>;
|
|
520
|
+
|
|
521
|
+
declare function handleSourceUpsert(args: {
|
|
522
|
+
authContext: GatewayAuthContext;
|
|
523
|
+
correlationId: string;
|
|
524
|
+
policyTraceId: string;
|
|
525
|
+
body: unknown;
|
|
526
|
+
}): Promise<Response>;
|
|
527
|
+
declare function handleSourceGet(args: {
|
|
528
|
+
authContext: GatewayAuthContext;
|
|
529
|
+
correlationId: string;
|
|
530
|
+
policyTraceId: string;
|
|
531
|
+
sourceId: string;
|
|
532
|
+
}): Promise<Response>;
|
|
533
|
+
|
|
534
|
+
declare function handleTaskCreate(args: {
|
|
535
|
+
authContext: GatewayAuthContext;
|
|
536
|
+
correlationId: string;
|
|
537
|
+
policyTraceId: string;
|
|
538
|
+
body: unknown;
|
|
539
|
+
}): Promise<Response>;
|
|
540
|
+
declare function handleTaskList(args: {
|
|
541
|
+
authContext: GatewayAuthContext;
|
|
542
|
+
correlationId: string;
|
|
543
|
+
policyTraceId: string;
|
|
544
|
+
query: {
|
|
545
|
+
topicId?: string;
|
|
546
|
+
worktreeId?: string;
|
|
547
|
+
status?: string;
|
|
548
|
+
limit?: number;
|
|
549
|
+
};
|
|
550
|
+
}): Promise<Response>;
|
|
551
|
+
declare function handleTaskUpdate(args: {
|
|
552
|
+
authContext: GatewayAuthContext;
|
|
553
|
+
correlationId: string;
|
|
554
|
+
policyTraceId: string;
|
|
555
|
+
taskId: string;
|
|
556
|
+
body: unknown;
|
|
557
|
+
}): Promise<Response>;
|
|
558
|
+
declare function handleTaskComplete(args: {
|
|
559
|
+
authContext: GatewayAuthContext;
|
|
560
|
+
correlationId: string;
|
|
561
|
+
policyTraceId: string;
|
|
562
|
+
taskId: string;
|
|
563
|
+
body: unknown;
|
|
564
|
+
}): Promise<Response>;
|
|
565
|
+
|
|
566
|
+
declare function handleTopicCreate(args: {
|
|
567
|
+
authContext: GatewayAuthContext;
|
|
568
|
+
correlationId: string;
|
|
569
|
+
policyTraceId: string;
|
|
570
|
+
body: unknown;
|
|
571
|
+
}): Promise<Response>;
|
|
572
|
+
declare function handleTopicUpdate(args: {
|
|
573
|
+
authContext: GatewayAuthContext;
|
|
574
|
+
correlationId: string;
|
|
575
|
+
policyTraceId: string;
|
|
576
|
+
topicId: string;
|
|
577
|
+
body: unknown;
|
|
578
|
+
}): Promise<Response>;
|
|
579
|
+
declare function handleTopicGet(args: {
|
|
580
|
+
authContext: GatewayAuthContext;
|
|
581
|
+
correlationId: string;
|
|
582
|
+
policyTraceId: string;
|
|
583
|
+
topicId: string;
|
|
584
|
+
}): Promise<Response>;
|
|
585
|
+
declare function handleTopicList(args: {
|
|
586
|
+
authContext: GatewayAuthContext;
|
|
587
|
+
correlationId: string;
|
|
588
|
+
policyTraceId: string;
|
|
589
|
+
query: {
|
|
590
|
+
ontologyId?: string;
|
|
591
|
+
parentTopicId?: string;
|
|
592
|
+
status?: string;
|
|
593
|
+
type?: string;
|
|
594
|
+
};
|
|
595
|
+
}): Promise<Response>;
|
|
596
|
+
declare function handleTopicTree(args: {
|
|
597
|
+
authContext: GatewayAuthContext;
|
|
598
|
+
correlationId: string;
|
|
599
|
+
policyTraceId: string;
|
|
600
|
+
topicId: string;
|
|
601
|
+
query: {
|
|
602
|
+
maxDepth?: number;
|
|
603
|
+
};
|
|
604
|
+
}): Promise<Response>;
|
|
605
|
+
declare function handleTopicCoverage(args: {
|
|
606
|
+
authContext: GatewayAuthContext;
|
|
607
|
+
correlationId: string;
|
|
608
|
+
policyTraceId: string;
|
|
609
|
+
topicId: string;
|
|
610
|
+
query: {
|
|
611
|
+
includeDescendants?: boolean;
|
|
612
|
+
maxDepth?: number;
|
|
613
|
+
};
|
|
614
|
+
}): Promise<Response>;
|
|
615
|
+
declare function handleTopicRemove(args: {
|
|
616
|
+
authContext: GatewayAuthContext;
|
|
617
|
+
correlationId: string;
|
|
618
|
+
policyTraceId: string;
|
|
619
|
+
body: unknown;
|
|
620
|
+
}): Promise<Response>;
|
|
621
|
+
declare function handleTopicBulkCreate(args: {
|
|
622
|
+
authContext: GatewayAuthContext;
|
|
623
|
+
correlationId: string;
|
|
624
|
+
policyTraceId: string;
|
|
625
|
+
body: unknown;
|
|
626
|
+
}): Promise<Response>;
|
|
627
|
+
|
|
628
|
+
declare function handleWebhookCreate(args: {
|
|
629
|
+
authContext: GatewayAuthContext;
|
|
630
|
+
correlationId: string;
|
|
631
|
+
policyTraceId: string;
|
|
632
|
+
body: unknown;
|
|
633
|
+
}): Promise<Response>;
|
|
634
|
+
declare function handleWebhookList(args: {
|
|
635
|
+
authContext: GatewayAuthContext;
|
|
636
|
+
correlationId: string;
|
|
637
|
+
policyTraceId: string;
|
|
638
|
+
query: {
|
|
639
|
+
topicId?: string;
|
|
640
|
+
};
|
|
641
|
+
}): Promise<Response>;
|
|
642
|
+
declare function handleWebhookGet(args: {
|
|
643
|
+
authContext: GatewayAuthContext;
|
|
644
|
+
correlationId: string;
|
|
645
|
+
policyTraceId: string;
|
|
646
|
+
webhookId: string;
|
|
647
|
+
}): Promise<Response>;
|
|
648
|
+
declare function handleWebhookUpdate(args: {
|
|
649
|
+
authContext: GatewayAuthContext;
|
|
650
|
+
correlationId: string;
|
|
651
|
+
policyTraceId: string;
|
|
652
|
+
webhookId: string;
|
|
653
|
+
body: unknown;
|
|
654
|
+
}): Promise<Response>;
|
|
655
|
+
declare function handleWebhookDelete(args: {
|
|
656
|
+
authContext: GatewayAuthContext;
|
|
657
|
+
correlationId: string;
|
|
658
|
+
policyTraceId: string;
|
|
659
|
+
webhookId: string;
|
|
660
|
+
}): Promise<Response>;
|
|
661
|
+
declare function handleWebhookTest(args: {
|
|
662
|
+
authContext: GatewayAuthContext;
|
|
663
|
+
correlationId: string;
|
|
664
|
+
policyTraceId: string;
|
|
665
|
+
webhookId: string;
|
|
666
|
+
body: unknown;
|
|
667
|
+
}): Promise<Response>;
|
|
668
|
+
declare function handleWebhookDeliveries(args: {
|
|
669
|
+
authContext: GatewayAuthContext;
|
|
670
|
+
correlationId: string;
|
|
671
|
+
policyTraceId: string;
|
|
672
|
+
webhookId: string;
|
|
673
|
+
query: {
|
|
674
|
+
limit?: number;
|
|
675
|
+
};
|
|
676
|
+
}): Promise<Response>;
|
|
677
|
+
declare function handleWebhookHealth(args: {
|
|
678
|
+
authContext: GatewayAuthContext;
|
|
679
|
+
correlationId: string;
|
|
680
|
+
policyTraceId: string;
|
|
681
|
+
webhookId: string;
|
|
682
|
+
}): Promise<Response>;
|
|
683
|
+
|
|
684
|
+
declare function handleWorktreeCreate(args: {
|
|
685
|
+
authContext: GatewayAuthContext;
|
|
686
|
+
correlationId: string;
|
|
687
|
+
policyTraceId: string;
|
|
688
|
+
body: unknown;
|
|
689
|
+
}): Promise<Response>;
|
|
690
|
+
declare function handleWorktreeList(args: {
|
|
691
|
+
authContext: GatewayAuthContext;
|
|
692
|
+
correlationId: string;
|
|
693
|
+
policyTraceId: string;
|
|
694
|
+
query: {
|
|
695
|
+
topicId?: string;
|
|
696
|
+
status?: string;
|
|
697
|
+
limit?: number;
|
|
698
|
+
};
|
|
699
|
+
}): Promise<Response>;
|
|
700
|
+
declare function handleWorktreeListAll(args: {
|
|
701
|
+
authContext: GatewayAuthContext;
|
|
702
|
+
correlationId: string;
|
|
703
|
+
policyTraceId: string;
|
|
704
|
+
query: {
|
|
705
|
+
status?: string;
|
|
706
|
+
track?: string;
|
|
707
|
+
executionBand?: number;
|
|
708
|
+
limit?: number;
|
|
709
|
+
};
|
|
710
|
+
}): Promise<Response>;
|
|
711
|
+
declare function handleWorktreeActivate(args: {
|
|
712
|
+
authContext: GatewayAuthContext;
|
|
713
|
+
correlationId: string;
|
|
714
|
+
policyTraceId: string;
|
|
715
|
+
worktreeId: string;
|
|
716
|
+
}): Promise<Response>;
|
|
717
|
+
declare function handleWorktreeUpdate(args: {
|
|
718
|
+
authContext: GatewayAuthContext;
|
|
719
|
+
correlationId: string;
|
|
720
|
+
policyTraceId: string;
|
|
721
|
+
worktreeId: string;
|
|
722
|
+
body: unknown;
|
|
723
|
+
}): Promise<Response>;
|
|
724
|
+
declare function handleWorktreeMerge(args: {
|
|
725
|
+
authContext: GatewayAuthContext;
|
|
726
|
+
correlationId: string;
|
|
727
|
+
policyTraceId: string;
|
|
728
|
+
worktreeId: string;
|
|
729
|
+
body: unknown;
|
|
730
|
+
}): Promise<Response>;
|
|
731
|
+
declare function handleWorktreeUpdateTargets(args: {
|
|
732
|
+
authContext: GatewayAuthContext;
|
|
733
|
+
correlationId: string;
|
|
734
|
+
policyTraceId: string;
|
|
735
|
+
worktreeId: string;
|
|
736
|
+
body: unknown;
|
|
737
|
+
}): Promise<Response>;
|
|
738
|
+
declare function handleWorktreeComplete(args: {
|
|
739
|
+
authContext: GatewayAuthContext;
|
|
740
|
+
correlationId: string;
|
|
741
|
+
policyTraceId: string;
|
|
742
|
+
body: unknown;
|
|
743
|
+
}): Promise<Response>;
|
|
744
|
+
declare function handleWorktreeAdvancePhase(args: {
|
|
745
|
+
authContext: GatewayAuthContext;
|
|
746
|
+
correlationId: string;
|
|
747
|
+
policyTraceId: string;
|
|
748
|
+
body: unknown;
|
|
749
|
+
}): Promise<Response>;
|
|
750
|
+
declare function handleWorktreeSetPhase(args: {
|
|
751
|
+
authContext: GatewayAuthContext;
|
|
752
|
+
correlationId: string;
|
|
753
|
+
policyTraceId: string;
|
|
754
|
+
body: unknown;
|
|
755
|
+
}): Promise<Response>;
|
|
756
|
+
declare function handleWorktreePatchState(args: {
|
|
757
|
+
authContext: GatewayAuthContext;
|
|
758
|
+
correlationId: string;
|
|
759
|
+
policyTraceId: string;
|
|
760
|
+
body: unknown;
|
|
761
|
+
}): Promise<Response>;
|
|
762
|
+
declare function handleWorktreeBulkCreate(args: {
|
|
763
|
+
authContext: GatewayAuthContext;
|
|
764
|
+
correlationId: string;
|
|
765
|
+
policyTraceId: string;
|
|
766
|
+
body: unknown;
|
|
767
|
+
}): Promise<Response>;
|
|
768
|
+
|
|
769
|
+
export { handleBeliefArchive, handleBeliefBatchUpdateCriticality, handleBeliefBisect, handleBeliefConfidenceHistory, handleBeliefCreate, handleBeliefCreateContract, handleBeliefFork, handleBeliefGet, handleBeliefLineage, handleBeliefLink, handleBeliefList, handleBeliefReassignTopic, handleBeliefRefine, handleBeliefRelationships, handleBeliefUnlinkEvidence, handleBeliefUpdateConfidence, handleBeliefUpdateCriticality, handleBeliefUpdateRationale, handleBeliefUpdateStatus, handleContradictionFlag, handleContradictionGet, handleContradictionList, handleEdgeBatchCreate, handleEdgeCreate, handleEdgeDelete, handleEdgeList, handleEdgeRemove, handleEdgeTraverse, handleEdgeUpdate, handleEdgesRemoveBetween, handleEventsList, handleEventsReplay, handleEvidenceClassify, handleEvidenceClassifyBatch, handleEvidenceCreate, handleEvidenceFlagIncorrect, handleEvidenceGet, handleEvidenceLink, handleEvidenceList, handleEvidenceRemove, handleEvidenceSearch, handleEvidenceUpdate, handleEvidenceUpdateStatus, handleEvidenceUpdateVerificationStatus, handleGraphAnalyze, handleGraphBias, handleGraphFalsify, handleGraphGaps, handleGraphNeighborhood, handleGraphTraverse, handleIdentityWhoami, handleOntologyBind, handleOntologyGet, handleOntologyList, handleOntologyMatch, handleQuestionAdd, handleQuestionAdvanceToConviction, handleQuestionAnswer, handleQuestionArchive, handleQuestionBatchCreate, handleQuestionCreate, handleQuestionDelete, handleQuestionFinalizeConviction, handleQuestionGet, handleQuestionGetAnswer, handleQuestionList, handleQuestionRefine, handleQuestionUpdate, handleQuestionUpdateConviction, handleQuestionUpdatePriority, handleQuestionUpdateStatus, handleSearchResources, handleSourceGet, handleSourceUpsert, handleTaskComplete, handleTaskCreate, handleTaskList, handleTaskUpdate, handleTopicBulkCreate, handleTopicCoverage, handleTopicCreate, handleTopicGet, handleTopicList, handleTopicRemove, handleTopicTree, handleTopicUpdate, handleWebhookCreate, handleWebhookDelete, handleWebhookDeliveries, handleWebhookGet, handleWebhookHealth, handleWebhookList, handleWebhookTest, handleWebhookUpdate, handleWorktreeActivate, handleWorktreeAdvancePhase, handleWorktreeBulkCreate, handleWorktreeComplete, handleWorktreeCreate, handleWorktreeList, handleWorktreeListAll, handleWorktreeMerge, handleWorktreePatchState, handleWorktreeSetPhase, handleWorktreeUpdate, handleWorktreeUpdateTargets };
|