@uniformdev/mesh-edgehancer-sdk 20.35.1-alpha.87 → 20.36.1-alpha.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.mts +1028 -134
- package/dist/index.d.ts +1028 -134
- package/dist/index.esm.js +252 -74
- package/dist/index.js +257 -71
- package/dist/index.mjs +252 -74
- package/package.json +3 -3
package/dist/index.d.mts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
|
-
import * as
|
|
1
|
+
import * as _uniformdev_canvas from '@uniformdev/canvas';
|
|
2
2
|
import { DataType, DataSource, DataSourceVariantsKeys, DataSourceVariantData } from '@uniformdev/canvas';
|
|
3
|
+
import * as z from 'zod';
|
|
3
4
|
|
|
4
5
|
/**
|
|
5
6
|
* The context we are fetching the data resource in:
|
|
@@ -31,12 +32,18 @@ declare const resolvingIssueSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{
|
|
|
31
32
|
declare const customEdgehancerDefinitionSchema: z.ZodObject<{
|
|
32
33
|
preRequest: z.ZodOptional<z.ZodString>;
|
|
33
34
|
request: z.ZodOptional<z.ZodString>;
|
|
35
|
+
createAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
36
|
+
afterAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
34
37
|
}, "strip", z.ZodTypeAny, {
|
|
35
38
|
preRequest?: string | undefined;
|
|
36
39
|
request?: string | undefined;
|
|
40
|
+
createAIDataResourceEdit?: string | undefined;
|
|
41
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
37
42
|
}, {
|
|
38
43
|
preRequest?: string | undefined;
|
|
39
44
|
request?: string | undefined;
|
|
45
|
+
createAIDataResourceEdit?: string | undefined;
|
|
46
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
40
47
|
}>;
|
|
41
48
|
declare const mergedDataTypeSchema: z.ZodObject<{
|
|
42
49
|
id: z.ZodString;
|
|
@@ -51,12 +58,12 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
51
58
|
value: z.ZodString;
|
|
52
59
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
53
60
|
}, "strip", z.ZodTypeAny, {
|
|
54
|
-
key: string;
|
|
55
61
|
value: string;
|
|
62
|
+
key: string;
|
|
56
63
|
omitIfEmpty?: boolean | undefined;
|
|
57
64
|
}, {
|
|
58
|
-
key: string;
|
|
59
65
|
value: string;
|
|
66
|
+
key: string;
|
|
60
67
|
omitIfEmpty?: boolean | undefined;
|
|
61
68
|
}>, "many">>;
|
|
62
69
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -64,12 +71,12 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
64
71
|
value: z.ZodString;
|
|
65
72
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
66
73
|
}, "strip", z.ZodTypeAny, {
|
|
67
|
-
key: string;
|
|
68
74
|
value: string;
|
|
75
|
+
key: string;
|
|
69
76
|
omitIfEmpty?: boolean | undefined;
|
|
70
77
|
}, {
|
|
71
|
-
key: string;
|
|
72
78
|
value: string;
|
|
79
|
+
key: string;
|
|
73
80
|
omitIfEmpty?: boolean | undefined;
|
|
74
81
|
}>, "many">>;
|
|
75
82
|
body: z.ZodOptional<z.ZodString>;
|
|
@@ -104,12 +111,18 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
104
111
|
edgehancer: z.ZodOptional<z.ZodObject<{
|
|
105
112
|
preRequest: z.ZodOptional<z.ZodString>;
|
|
106
113
|
request: z.ZodOptional<z.ZodString>;
|
|
114
|
+
createAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
115
|
+
afterAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
107
116
|
}, "strip", z.ZodTypeAny, {
|
|
108
117
|
preRequest?: string | undefined;
|
|
109
118
|
request?: string | undefined;
|
|
119
|
+
createAIDataResourceEdit?: string | undefined;
|
|
120
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
110
121
|
}, {
|
|
111
122
|
preRequest?: string | undefined;
|
|
112
123
|
request?: string | undefined;
|
|
124
|
+
createAIDataResourceEdit?: string | undefined;
|
|
125
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
113
126
|
}>>;
|
|
114
127
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
115
128
|
variants: z.ZodOptional<z.ZodObject<{
|
|
@@ -119,12 +132,12 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
119
132
|
value: z.ZodString;
|
|
120
133
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
121
134
|
}, "strip", z.ZodTypeAny, {
|
|
122
|
-
key: string;
|
|
123
135
|
value: string;
|
|
136
|
+
key: string;
|
|
124
137
|
omitIfEmpty?: boolean | undefined;
|
|
125
138
|
}, {
|
|
126
|
-
key: string;
|
|
127
139
|
value: string;
|
|
140
|
+
key: string;
|
|
128
141
|
omitIfEmpty?: boolean | undefined;
|
|
129
142
|
}>, "many">>;
|
|
130
143
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -132,12 +145,12 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
132
145
|
value: z.ZodString;
|
|
133
146
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
134
147
|
}, "strip", z.ZodTypeAny, {
|
|
135
|
-
key: string;
|
|
136
148
|
value: string;
|
|
149
|
+
key: string;
|
|
137
150
|
omitIfEmpty?: boolean | undefined;
|
|
138
151
|
}, {
|
|
139
|
-
key: string;
|
|
140
152
|
value: string;
|
|
153
|
+
key: string;
|
|
141
154
|
omitIfEmpty?: boolean | undefined;
|
|
142
155
|
}>, "many">>;
|
|
143
156
|
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -164,13 +177,13 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
164
177
|
}>>>;
|
|
165
178
|
}, "strip", z.ZodTypeAny, {
|
|
166
179
|
headers?: {
|
|
167
|
-
key: string;
|
|
168
180
|
value: string;
|
|
181
|
+
key: string;
|
|
169
182
|
omitIfEmpty?: boolean | undefined;
|
|
170
183
|
}[] | undefined;
|
|
171
184
|
parameters?: {
|
|
172
|
-
key: string;
|
|
173
185
|
value: string;
|
|
186
|
+
key: string;
|
|
174
187
|
omitIfEmpty?: boolean | undefined;
|
|
175
188
|
}[] | undefined;
|
|
176
189
|
variables?: Record<string, {
|
|
@@ -183,13 +196,13 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
183
196
|
}> | undefined;
|
|
184
197
|
}, {
|
|
185
198
|
headers?: {
|
|
186
|
-
key: string;
|
|
187
199
|
value: string;
|
|
200
|
+
key: string;
|
|
188
201
|
omitIfEmpty?: boolean | undefined;
|
|
189
202
|
}[] | undefined;
|
|
190
203
|
parameters?: {
|
|
191
|
-
key: string;
|
|
192
204
|
value: string;
|
|
205
|
+
key: string;
|
|
193
206
|
omitIfEmpty?: boolean | undefined;
|
|
194
207
|
}[] | undefined;
|
|
195
208
|
variables?: Record<string, {
|
|
@@ -210,13 +223,13 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
210
223
|
}, "strip", z.ZodTypeAny, {
|
|
211
224
|
unpublished?: ({
|
|
212
225
|
headers?: {
|
|
213
|
-
key: string;
|
|
214
226
|
value: string;
|
|
227
|
+
key: string;
|
|
215
228
|
omitIfEmpty?: boolean | undefined;
|
|
216
229
|
}[] | undefined;
|
|
217
230
|
parameters?: {
|
|
218
|
-
key: string;
|
|
219
231
|
value: string;
|
|
232
|
+
key: string;
|
|
220
233
|
omitIfEmpty?: boolean | undefined;
|
|
221
234
|
}[] | undefined;
|
|
222
235
|
variables?: Record<string, {
|
|
@@ -233,13 +246,13 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
233
246
|
}, {
|
|
234
247
|
unpublished?: ({
|
|
235
248
|
headers?: {
|
|
236
|
-
key: string;
|
|
237
249
|
value: string;
|
|
250
|
+
key: string;
|
|
238
251
|
omitIfEmpty?: boolean | undefined;
|
|
239
252
|
}[] | undefined;
|
|
240
253
|
parameters?: {
|
|
241
|
-
key: string;
|
|
242
254
|
value: string;
|
|
255
|
+
key: string;
|
|
243
256
|
omitIfEmpty?: boolean | undefined;
|
|
244
257
|
}[] | undefined;
|
|
245
258
|
variables?: Record<string, {
|
|
@@ -256,20 +269,20 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
256
269
|
}>>;
|
|
257
270
|
enableUnpublishedMode: z.ZodOptional<z.ZodBoolean>;
|
|
258
271
|
}, "strip", z.ZodTypeAny, {
|
|
272
|
+
id: string;
|
|
259
273
|
displayName: string;
|
|
260
274
|
url: string;
|
|
261
|
-
id: string;
|
|
262
275
|
connectorType: string;
|
|
263
276
|
method: "GET" | "POST" | "HEAD";
|
|
264
277
|
custom?: Record<string, unknown> | undefined;
|
|
265
278
|
headers?: {
|
|
266
|
-
key: string;
|
|
267
279
|
value: string;
|
|
280
|
+
key: string;
|
|
268
281
|
omitIfEmpty?: boolean | undefined;
|
|
269
282
|
}[] | undefined;
|
|
270
283
|
parameters?: {
|
|
271
|
-
key: string;
|
|
272
284
|
value: string;
|
|
285
|
+
key: string;
|
|
273
286
|
omitIfEmpty?: boolean | undefined;
|
|
274
287
|
}[] | undefined;
|
|
275
288
|
variables?: Record<string, {
|
|
@@ -291,18 +304,20 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
291
304
|
edgehancer?: {
|
|
292
305
|
preRequest?: string | undefined;
|
|
293
306
|
request?: string | undefined;
|
|
307
|
+
createAIDataResourceEdit?: string | undefined;
|
|
308
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
294
309
|
} | undefined;
|
|
295
310
|
uiBadgeText?: string | undefined;
|
|
296
311
|
variants?: {
|
|
297
312
|
unpublished?: ({
|
|
298
313
|
headers?: {
|
|
299
|
-
key: string;
|
|
300
314
|
value: string;
|
|
315
|
+
key: string;
|
|
301
316
|
omitIfEmpty?: boolean | undefined;
|
|
302
317
|
}[] | undefined;
|
|
303
318
|
parameters?: {
|
|
304
|
-
key: string;
|
|
305
319
|
value: string;
|
|
320
|
+
key: string;
|
|
306
321
|
omitIfEmpty?: boolean | undefined;
|
|
307
322
|
}[] | undefined;
|
|
308
323
|
variables?: Record<string, {
|
|
@@ -319,20 +334,20 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
319
334
|
} | undefined;
|
|
320
335
|
enableUnpublishedMode?: boolean | undefined;
|
|
321
336
|
}, {
|
|
337
|
+
id: string;
|
|
322
338
|
displayName: string;
|
|
323
339
|
url: string;
|
|
324
|
-
id: string;
|
|
325
340
|
connectorType: string;
|
|
326
341
|
method: "GET" | "POST" | "HEAD";
|
|
327
342
|
custom?: Record<string, unknown> | undefined;
|
|
328
343
|
headers?: {
|
|
329
|
-
key: string;
|
|
330
344
|
value: string;
|
|
345
|
+
key: string;
|
|
331
346
|
omitIfEmpty?: boolean | undefined;
|
|
332
347
|
}[] | undefined;
|
|
333
348
|
parameters?: {
|
|
334
|
-
key: string;
|
|
335
349
|
value: string;
|
|
350
|
+
key: string;
|
|
336
351
|
omitIfEmpty?: boolean | undefined;
|
|
337
352
|
}[] | undefined;
|
|
338
353
|
variables?: Record<string, {
|
|
@@ -354,18 +369,20 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
354
369
|
edgehancer?: {
|
|
355
370
|
preRequest?: string | undefined;
|
|
356
371
|
request?: string | undefined;
|
|
372
|
+
createAIDataResourceEdit?: string | undefined;
|
|
373
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
357
374
|
} | undefined;
|
|
358
375
|
uiBadgeText?: string | undefined;
|
|
359
376
|
variants?: {
|
|
360
377
|
unpublished?: ({
|
|
361
378
|
headers?: {
|
|
362
|
-
key: string;
|
|
363
379
|
value: string;
|
|
380
|
+
key: string;
|
|
364
381
|
omitIfEmpty?: boolean | undefined;
|
|
365
382
|
}[] | undefined;
|
|
366
383
|
parameters?: {
|
|
367
|
-
key: string;
|
|
368
384
|
value: string;
|
|
385
|
+
key: string;
|
|
369
386
|
omitIfEmpty?: boolean | undefined;
|
|
370
387
|
}[] | undefined;
|
|
371
388
|
variables?: Record<string, {
|
|
@@ -417,6 +434,467 @@ declare const dataResourceSchema: z.ZodUnion<[z.ZodString, z.ZodObject<{}, "stri
|
|
|
417
434
|
type DataResource = z.infer<typeof dataResourceSchema>;
|
|
418
435
|
type EdgehancerDataIssue = z.infer<typeof resolvingIssueSchema>;
|
|
419
436
|
|
|
437
|
+
declare const afterAIDataResourceEditResultSchema: z.ZodObject<{
|
|
438
|
+
newValue: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
439
|
+
success: z.ZodBoolean;
|
|
440
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
441
|
+
}, "strict", z.ZodTypeAny, {
|
|
442
|
+
newValue: Record<string, string>;
|
|
443
|
+
success: boolean;
|
|
444
|
+
summary?: string | undefined;
|
|
445
|
+
}, {
|
|
446
|
+
newValue: Record<string, string>;
|
|
447
|
+
success: boolean;
|
|
448
|
+
summary?: string | undefined;
|
|
449
|
+
}>;
|
|
450
|
+
declare const afterAIDataResourceEditContextSchema: z.ZodObject<{
|
|
451
|
+
/**
|
|
452
|
+
* The the data type of the data resource being edited (merged with its data source)
|
|
453
|
+
* NOTE: this can contain secrets, API keys, etc. Do not directly expose it to the AI agent!
|
|
454
|
+
* NOTE: this does not include the current value's variables, if any
|
|
455
|
+
*/
|
|
456
|
+
mergedDataType: z.ZodType<MergedDataType, z.ZodTypeDef, MergedDataType>;
|
|
457
|
+
/** Which data source variant is currently active (undefined = published data) */
|
|
458
|
+
dataSourceVariant: z.ZodOptional<z.ZodType<"unpublished", z.ZodTypeDef, "unpublished">>;
|
|
459
|
+
/** The edit request details */
|
|
460
|
+
editRequest: z.ZodObject<{
|
|
461
|
+
/** The edit instruction from the AI agent */
|
|
462
|
+
edit: z.ZodString;
|
|
463
|
+
/** Current value of the data resource's variables (if any) */
|
|
464
|
+
currentValue: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
465
|
+
}, "strip", z.ZodTypeAny, {
|
|
466
|
+
edit: string;
|
|
467
|
+
currentValue?: Record<string, string> | undefined;
|
|
468
|
+
}, {
|
|
469
|
+
edit: string;
|
|
470
|
+
currentValue?: Record<string, string> | undefined;
|
|
471
|
+
}>;
|
|
472
|
+
/** AI invocation context */
|
|
473
|
+
invocationContext: z.ZodEnum<["composition", "compositionPattern", "componentPattern", "entry", "entryPattern", "general"]>;
|
|
474
|
+
/** User ID making the edit */
|
|
475
|
+
userId: z.ZodString;
|
|
476
|
+
/** Project ID */
|
|
477
|
+
projectId: z.ZodString;
|
|
478
|
+
/** The new value generated by AI */
|
|
479
|
+
newValue: z.ZodRecord<z.ZodString, z.ZodString>;
|
|
480
|
+
/** The result from the AI editing process */
|
|
481
|
+
result: z.ZodObject<{
|
|
482
|
+
success: z.ZodBoolean;
|
|
483
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
484
|
+
}, "strip", z.ZodTypeAny, {
|
|
485
|
+
success: boolean;
|
|
486
|
+
summary?: string | undefined;
|
|
487
|
+
}, {
|
|
488
|
+
success: boolean;
|
|
489
|
+
summary?: string | undefined;
|
|
490
|
+
}>;
|
|
491
|
+
}, "strict", z.ZodTypeAny, {
|
|
492
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
493
|
+
newValue: Record<string, string>;
|
|
494
|
+
mergedDataType: Omit<{
|
|
495
|
+
id: string;
|
|
496
|
+
displayName: string;
|
|
497
|
+
dataSourceId: string;
|
|
498
|
+
archetype?: string;
|
|
499
|
+
allowedOnComponents?: string[];
|
|
500
|
+
path: string;
|
|
501
|
+
ttl?: number;
|
|
502
|
+
purgeKey?: string;
|
|
503
|
+
badgeIconUrl?: string;
|
|
504
|
+
headers?: {
|
|
505
|
+
key: string;
|
|
506
|
+
value: string;
|
|
507
|
+
omitIfEmpty?: boolean;
|
|
508
|
+
}[];
|
|
509
|
+
parameters?: {
|
|
510
|
+
key: string;
|
|
511
|
+
value: string;
|
|
512
|
+
omitIfEmpty?: boolean;
|
|
513
|
+
}[];
|
|
514
|
+
body?: string;
|
|
515
|
+
method: "GET" | "POST" | "HEAD";
|
|
516
|
+
variables?: {
|
|
517
|
+
[key: string]: {
|
|
518
|
+
displayName?: string;
|
|
519
|
+
helpText?: string;
|
|
520
|
+
type?: string;
|
|
521
|
+
default: string;
|
|
522
|
+
order?: number;
|
|
523
|
+
source?: string;
|
|
524
|
+
};
|
|
525
|
+
};
|
|
526
|
+
custom?: {
|
|
527
|
+
[key: string]: unknown;
|
|
528
|
+
};
|
|
529
|
+
}, "path" | "dataSourceId"> & Pick<{
|
|
530
|
+
id: string;
|
|
531
|
+
displayName: string;
|
|
532
|
+
connectorType: string;
|
|
533
|
+
baseUrl: string;
|
|
534
|
+
headers?: {
|
|
535
|
+
key: string;
|
|
536
|
+
value: string;
|
|
537
|
+
}[];
|
|
538
|
+
parameters?: {
|
|
539
|
+
key: string;
|
|
540
|
+
value: string;
|
|
541
|
+
}[];
|
|
542
|
+
variables?: {
|
|
543
|
+
[key: string]: {
|
|
544
|
+
displayName?: string;
|
|
545
|
+
helpText?: string;
|
|
546
|
+
type?: string;
|
|
547
|
+
default: string;
|
|
548
|
+
order?: number;
|
|
549
|
+
source?: string;
|
|
550
|
+
};
|
|
551
|
+
};
|
|
552
|
+
localeMapping?: {
|
|
553
|
+
[key: string]: string;
|
|
554
|
+
};
|
|
555
|
+
enableUnpublishedMode?: boolean;
|
|
556
|
+
customPublic?: {
|
|
557
|
+
[key: string]: unknown;
|
|
558
|
+
};
|
|
559
|
+
custom?: {
|
|
560
|
+
[key: string]: unknown;
|
|
561
|
+
};
|
|
562
|
+
variants?: {
|
|
563
|
+
unpublished?: {
|
|
564
|
+
baseUrl: string;
|
|
565
|
+
headers?: {
|
|
566
|
+
key: string;
|
|
567
|
+
value: string;
|
|
568
|
+
omitIfEmpty?: boolean;
|
|
569
|
+
}[];
|
|
570
|
+
parameters?: {
|
|
571
|
+
key: string;
|
|
572
|
+
value: string;
|
|
573
|
+
omitIfEmpty?: boolean;
|
|
574
|
+
}[];
|
|
575
|
+
variables?: {
|
|
576
|
+
[key: string]: {
|
|
577
|
+
displayName?: string;
|
|
578
|
+
helpText?: string;
|
|
579
|
+
type?: string;
|
|
580
|
+
default: string;
|
|
581
|
+
order?: number;
|
|
582
|
+
source?: string;
|
|
583
|
+
};
|
|
584
|
+
};
|
|
585
|
+
};
|
|
586
|
+
};
|
|
587
|
+
}, "connectorType" | "customPublic" | "localeMapping" | "enableUnpublishedMode"> & {
|
|
588
|
+
variants?: Partial<Record<DataSourceVariantsKeys, Omit<NonNullable<_uniformdev_canvas.DataSourceVariantData>, "baseUrl"> & {
|
|
589
|
+
url: string;
|
|
590
|
+
}>>;
|
|
591
|
+
url: string;
|
|
592
|
+
edgehancer?: CustomEdgehancerDefinition;
|
|
593
|
+
uiBadgeText?: string;
|
|
594
|
+
};
|
|
595
|
+
editRequest: {
|
|
596
|
+
edit: string;
|
|
597
|
+
currentValue?: Record<string, string> | undefined;
|
|
598
|
+
};
|
|
599
|
+
userId: string;
|
|
600
|
+
projectId: string;
|
|
601
|
+
result: {
|
|
602
|
+
success: boolean;
|
|
603
|
+
summary?: string | undefined;
|
|
604
|
+
};
|
|
605
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
606
|
+
}, {
|
|
607
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
608
|
+
newValue: Record<string, string>;
|
|
609
|
+
mergedDataType: Omit<{
|
|
610
|
+
id: string;
|
|
611
|
+
displayName: string;
|
|
612
|
+
dataSourceId: string;
|
|
613
|
+
archetype?: string;
|
|
614
|
+
allowedOnComponents?: string[];
|
|
615
|
+
path: string;
|
|
616
|
+
ttl?: number;
|
|
617
|
+
purgeKey?: string;
|
|
618
|
+
badgeIconUrl?: string;
|
|
619
|
+
headers?: {
|
|
620
|
+
key: string;
|
|
621
|
+
value: string;
|
|
622
|
+
omitIfEmpty?: boolean;
|
|
623
|
+
}[];
|
|
624
|
+
parameters?: {
|
|
625
|
+
key: string;
|
|
626
|
+
value: string;
|
|
627
|
+
omitIfEmpty?: boolean;
|
|
628
|
+
}[];
|
|
629
|
+
body?: string;
|
|
630
|
+
method: "GET" | "POST" | "HEAD";
|
|
631
|
+
variables?: {
|
|
632
|
+
[key: string]: {
|
|
633
|
+
displayName?: string;
|
|
634
|
+
helpText?: string;
|
|
635
|
+
type?: string;
|
|
636
|
+
default: string;
|
|
637
|
+
order?: number;
|
|
638
|
+
source?: string;
|
|
639
|
+
};
|
|
640
|
+
};
|
|
641
|
+
custom?: {
|
|
642
|
+
[key: string]: unknown;
|
|
643
|
+
};
|
|
644
|
+
}, "path" | "dataSourceId"> & Pick<{
|
|
645
|
+
id: string;
|
|
646
|
+
displayName: string;
|
|
647
|
+
connectorType: string;
|
|
648
|
+
baseUrl: string;
|
|
649
|
+
headers?: {
|
|
650
|
+
key: string;
|
|
651
|
+
value: string;
|
|
652
|
+
}[];
|
|
653
|
+
parameters?: {
|
|
654
|
+
key: string;
|
|
655
|
+
value: string;
|
|
656
|
+
}[];
|
|
657
|
+
variables?: {
|
|
658
|
+
[key: string]: {
|
|
659
|
+
displayName?: string;
|
|
660
|
+
helpText?: string;
|
|
661
|
+
type?: string;
|
|
662
|
+
default: string;
|
|
663
|
+
order?: number;
|
|
664
|
+
source?: string;
|
|
665
|
+
};
|
|
666
|
+
};
|
|
667
|
+
localeMapping?: {
|
|
668
|
+
[key: string]: string;
|
|
669
|
+
};
|
|
670
|
+
enableUnpublishedMode?: boolean;
|
|
671
|
+
customPublic?: {
|
|
672
|
+
[key: string]: unknown;
|
|
673
|
+
};
|
|
674
|
+
custom?: {
|
|
675
|
+
[key: string]: unknown;
|
|
676
|
+
};
|
|
677
|
+
variants?: {
|
|
678
|
+
unpublished?: {
|
|
679
|
+
baseUrl: string;
|
|
680
|
+
headers?: {
|
|
681
|
+
key: string;
|
|
682
|
+
value: string;
|
|
683
|
+
omitIfEmpty?: boolean;
|
|
684
|
+
}[];
|
|
685
|
+
parameters?: {
|
|
686
|
+
key: string;
|
|
687
|
+
value: string;
|
|
688
|
+
omitIfEmpty?: boolean;
|
|
689
|
+
}[];
|
|
690
|
+
variables?: {
|
|
691
|
+
[key: string]: {
|
|
692
|
+
displayName?: string;
|
|
693
|
+
helpText?: string;
|
|
694
|
+
type?: string;
|
|
695
|
+
default: string;
|
|
696
|
+
order?: number;
|
|
697
|
+
source?: string;
|
|
698
|
+
};
|
|
699
|
+
};
|
|
700
|
+
};
|
|
701
|
+
};
|
|
702
|
+
}, "connectorType" | "customPublic" | "localeMapping" | "enableUnpublishedMode"> & {
|
|
703
|
+
variants?: Partial<Record<DataSourceVariantsKeys, Omit<NonNullable<_uniformdev_canvas.DataSourceVariantData>, "baseUrl"> & {
|
|
704
|
+
url: string;
|
|
705
|
+
}>>;
|
|
706
|
+
url: string;
|
|
707
|
+
edgehancer?: CustomEdgehancerDefinition;
|
|
708
|
+
uiBadgeText?: string;
|
|
709
|
+
};
|
|
710
|
+
editRequest: {
|
|
711
|
+
edit: string;
|
|
712
|
+
currentValue?: Record<string, string> | undefined;
|
|
713
|
+
};
|
|
714
|
+
userId: string;
|
|
715
|
+
projectId: string;
|
|
716
|
+
result: {
|
|
717
|
+
success: boolean;
|
|
718
|
+
summary?: string | undefined;
|
|
719
|
+
};
|
|
720
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
721
|
+
}>;
|
|
722
|
+
type AfterAIDataResourceEditContext = z.infer<typeof afterAIDataResourceEditContextSchema>;
|
|
723
|
+
type AfterAIDataResourceEditResult = z.infer<typeof afterAIDataResourceEditResultSchema>;
|
|
724
|
+
/**
|
|
725
|
+
* Shape of a hook function that is invoked after an AI edit has been performed on a data resource.
|
|
726
|
+
* The function can alter the success or value of the edit performed by the LLM.
|
|
727
|
+
*
|
|
728
|
+
* This hook allows you to:
|
|
729
|
+
* - Apply custom business rules to AI-generated edits
|
|
730
|
+
* - Detect and correct hallucinations in AI output
|
|
731
|
+
* - Transform the AI result into a different format
|
|
732
|
+
* - Validate that the AI edit meets your specific requirements
|
|
733
|
+
*
|
|
734
|
+
* NOTE: this function is only invoked when a value is edited. If the value is cleared or
|
|
735
|
+
* reset, the function is not invoked (those are internally handled).
|
|
736
|
+
*
|
|
737
|
+
* NOTE: in most cases, you want createAIDataResourceEdit well before this hook. This hook allows catching
|
|
738
|
+
* hallucinations, applying deterministic business rules, or transforming the format of the AI result
|
|
739
|
+
* into another format.
|
|
740
|
+
*/
|
|
741
|
+
type AfterAIDataResourceEditHookFn = (context: AfterAIDataResourceEditContext) => Promise<AfterAIDataResourceEditResult>;
|
|
742
|
+
|
|
743
|
+
declare const afterAIEditResultSchema: z.ZodObject<{
|
|
744
|
+
newValue: z.ZodUnknown;
|
|
745
|
+
success: z.ZodBoolean;
|
|
746
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
747
|
+
}, "strict", z.ZodTypeAny, {
|
|
748
|
+
success: boolean;
|
|
749
|
+
newValue?: unknown;
|
|
750
|
+
summary?: string | undefined;
|
|
751
|
+
}, {
|
|
752
|
+
success: boolean;
|
|
753
|
+
newValue?: unknown;
|
|
754
|
+
summary?: string | undefined;
|
|
755
|
+
}>;
|
|
756
|
+
declare const afterAIEditContextSchema: z.ZodObject<{
|
|
757
|
+
editRequest: z.ZodObject<{
|
|
758
|
+
edit: z.ZodString;
|
|
759
|
+
currentValue: z.ZodOptional<z.ZodUnknown>;
|
|
760
|
+
projectGuidance: z.ZodOptional<z.ZodString>;
|
|
761
|
+
componentGuidance: z.ZodOptional<z.ZodString>;
|
|
762
|
+
audienceGuidance: z.ZodOptional<z.ZodString>;
|
|
763
|
+
propertyDefinition: z.ZodObject<{
|
|
764
|
+
id: z.ZodString;
|
|
765
|
+
name: z.ZodString;
|
|
766
|
+
type: z.ZodString;
|
|
767
|
+
guidance: z.ZodOptional<z.ZodString>;
|
|
768
|
+
typeConfig: z.ZodOptional<z.ZodUnknown>;
|
|
769
|
+
}, "strip", z.ZodTypeAny, {
|
|
770
|
+
type: string;
|
|
771
|
+
id: string;
|
|
772
|
+
name: string;
|
|
773
|
+
guidance?: string | undefined;
|
|
774
|
+
typeConfig?: unknown;
|
|
775
|
+
}, {
|
|
776
|
+
type: string;
|
|
777
|
+
id: string;
|
|
778
|
+
name: string;
|
|
779
|
+
guidance?: string | undefined;
|
|
780
|
+
typeConfig?: unknown;
|
|
781
|
+
}>;
|
|
782
|
+
outputLocale: z.ZodOptional<z.ZodString>;
|
|
783
|
+
documentContext: z.ZodOptional<z.ZodString>;
|
|
784
|
+
}, "strip", z.ZodTypeAny, {
|
|
785
|
+
edit: string;
|
|
786
|
+
propertyDefinition: {
|
|
787
|
+
type: string;
|
|
788
|
+
id: string;
|
|
789
|
+
name: string;
|
|
790
|
+
guidance?: string | undefined;
|
|
791
|
+
typeConfig?: unknown;
|
|
792
|
+
};
|
|
793
|
+
currentValue?: unknown;
|
|
794
|
+
projectGuidance?: string | undefined;
|
|
795
|
+
componentGuidance?: string | undefined;
|
|
796
|
+
audienceGuidance?: string | undefined;
|
|
797
|
+
outputLocale?: string | undefined;
|
|
798
|
+
documentContext?: string | undefined;
|
|
799
|
+
}, {
|
|
800
|
+
edit: string;
|
|
801
|
+
propertyDefinition: {
|
|
802
|
+
type: string;
|
|
803
|
+
id: string;
|
|
804
|
+
name: string;
|
|
805
|
+
guidance?: string | undefined;
|
|
806
|
+
typeConfig?: unknown;
|
|
807
|
+
};
|
|
808
|
+
currentValue?: unknown;
|
|
809
|
+
projectGuidance?: string | undefined;
|
|
810
|
+
componentGuidance?: string | undefined;
|
|
811
|
+
audienceGuidance?: string | undefined;
|
|
812
|
+
outputLocale?: string | undefined;
|
|
813
|
+
documentContext?: string | undefined;
|
|
814
|
+
}>;
|
|
815
|
+
invocationContext: z.ZodEnum<["composition", "compositionPattern", "componentPattern", "entry", "entryPattern", "general"]>;
|
|
816
|
+
userId: z.ZodString;
|
|
817
|
+
currentLocale: z.ZodOptional<z.ZodString>;
|
|
818
|
+
projectId: z.ZodString;
|
|
819
|
+
newValue: z.ZodUnknown;
|
|
820
|
+
result: z.ZodObject<{
|
|
821
|
+
success: z.ZodBoolean;
|
|
822
|
+
summary: z.ZodOptional<z.ZodString>;
|
|
823
|
+
}, "strip", z.ZodTypeAny, {
|
|
824
|
+
success: boolean;
|
|
825
|
+
summary?: string | undefined;
|
|
826
|
+
}, {
|
|
827
|
+
success: boolean;
|
|
828
|
+
summary?: string | undefined;
|
|
829
|
+
}>;
|
|
830
|
+
}, "strict", z.ZodTypeAny, {
|
|
831
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
832
|
+
editRequest: {
|
|
833
|
+
edit: string;
|
|
834
|
+
propertyDefinition: {
|
|
835
|
+
type: string;
|
|
836
|
+
id: string;
|
|
837
|
+
name: string;
|
|
838
|
+
guidance?: string | undefined;
|
|
839
|
+
typeConfig?: unknown;
|
|
840
|
+
};
|
|
841
|
+
currentValue?: unknown;
|
|
842
|
+
projectGuidance?: string | undefined;
|
|
843
|
+
componentGuidance?: string | undefined;
|
|
844
|
+
audienceGuidance?: string | undefined;
|
|
845
|
+
outputLocale?: string | undefined;
|
|
846
|
+
documentContext?: string | undefined;
|
|
847
|
+
};
|
|
848
|
+
userId: string;
|
|
849
|
+
projectId: string;
|
|
850
|
+
result: {
|
|
851
|
+
success: boolean;
|
|
852
|
+
summary?: string | undefined;
|
|
853
|
+
};
|
|
854
|
+
newValue?: unknown;
|
|
855
|
+
currentLocale?: string | undefined;
|
|
856
|
+
}, {
|
|
857
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
858
|
+
editRequest: {
|
|
859
|
+
edit: string;
|
|
860
|
+
propertyDefinition: {
|
|
861
|
+
type: string;
|
|
862
|
+
id: string;
|
|
863
|
+
name: string;
|
|
864
|
+
guidance?: string | undefined;
|
|
865
|
+
typeConfig?: unknown;
|
|
866
|
+
};
|
|
867
|
+
currentValue?: unknown;
|
|
868
|
+
projectGuidance?: string | undefined;
|
|
869
|
+
componentGuidance?: string | undefined;
|
|
870
|
+
audienceGuidance?: string | undefined;
|
|
871
|
+
outputLocale?: string | undefined;
|
|
872
|
+
documentContext?: string | undefined;
|
|
873
|
+
};
|
|
874
|
+
userId: string;
|
|
875
|
+
projectId: string;
|
|
876
|
+
result: {
|
|
877
|
+
success: boolean;
|
|
878
|
+
summary?: string | undefined;
|
|
879
|
+
};
|
|
880
|
+
newValue?: unknown;
|
|
881
|
+
currentLocale?: string | undefined;
|
|
882
|
+
}>;
|
|
883
|
+
type AfterAIEditContext = z.infer<typeof afterAIEditContextSchema>;
|
|
884
|
+
type AfterAIEditResult = z.infer<typeof afterAIEditResultSchema>;
|
|
885
|
+
/**
|
|
886
|
+
* Shape of a hook function that is invoked after an AI edit has been performed to a custom property type.
|
|
887
|
+
* The function can alter the success or value of the edit performed by the LLM.
|
|
888
|
+
*
|
|
889
|
+
* NOTE: this function is only invoked when a value is edited. If the value is cleared or
|
|
890
|
+
* overrides reset, the function is not invoked (those are internally handled)
|
|
891
|
+
*
|
|
892
|
+
* NOTE: in most cases, you want createAIEdit well before this hook. This hook allows catching
|
|
893
|
+
* hallucinations, applying deterministic business rules, or transforming the format of the AI result
|
|
894
|
+
* into another format.
|
|
895
|
+
*/
|
|
896
|
+
type AfterAIEditHookFn = (context: AfterAIEditContext) => Promise<AfterAIEditResult>;
|
|
897
|
+
|
|
420
898
|
type RequestEdgehancerDataResourceContext = {
|
|
421
899
|
/**
|
|
422
900
|
* The data resource to fetch.
|
|
@@ -489,6 +967,7 @@ declare const requestEdgehancerDataResourceResolutionResultSchema: z.ZodObject<{
|
|
|
489
967
|
surrogateKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
490
968
|
result: z.ZodUnion<[z.ZodString, z.ZodObject<{}, "strip", z.ZodUnknown, z.objectOutputType<{}, z.ZodUnknown, "strip">, z.objectInputType<{}, z.ZodUnknown, "strip">>, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodUndefined]>;
|
|
491
969
|
}, "strict", z.ZodTypeAny, {
|
|
970
|
+
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
492
971
|
errors?: (string | {
|
|
493
972
|
message: string;
|
|
494
973
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -508,8 +987,8 @@ declare const requestEdgehancerDataResourceResolutionResultSchema: z.ZodObject<{
|
|
|
508
987
|
deepLink?: string | undefined;
|
|
509
988
|
})[] | undefined;
|
|
510
989
|
surrogateKeys?: string[] | undefined;
|
|
511
|
-
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
512
990
|
}, {
|
|
991
|
+
result?: string | number | boolean | unknown[] | z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
513
992
|
errors?: (string | {
|
|
514
993
|
message: string;
|
|
515
994
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -529,7 +1008,6 @@ declare const requestEdgehancerDataResourceResolutionResultSchema: z.ZodObject<{
|
|
|
529
1008
|
deepLink?: string | undefined;
|
|
530
1009
|
})[] | undefined;
|
|
531
1010
|
surrogateKeys?: string[] | undefined;
|
|
532
|
-
result?: string | number | boolean | unknown[] | z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
533
1011
|
}>;
|
|
534
1012
|
declare const requestEdgehancerResultSchema: z.ZodObject<{
|
|
535
1013
|
results: z.ZodArray<z.ZodObject<{
|
|
@@ -584,6 +1062,7 @@ declare const requestEdgehancerResultSchema: z.ZodObject<{
|
|
|
584
1062
|
surrogateKeys: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
585
1063
|
result: z.ZodUnion<[z.ZodString, z.ZodObject<{}, "strip", z.ZodUnknown, z.objectOutputType<{}, z.ZodUnknown, "strip">, z.objectInputType<{}, z.ZodUnknown, "strip">>, z.ZodNumber, z.ZodBoolean, z.ZodArray<z.ZodUnknown, "many">, z.ZodUndefined]>;
|
|
586
1064
|
}, "strict", z.ZodTypeAny, {
|
|
1065
|
+
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
587
1066
|
errors?: (string | {
|
|
588
1067
|
message: string;
|
|
589
1068
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -603,8 +1082,8 @@ declare const requestEdgehancerResultSchema: z.ZodObject<{
|
|
|
603
1082
|
deepLink?: string | undefined;
|
|
604
1083
|
})[] | undefined;
|
|
605
1084
|
surrogateKeys?: string[] | undefined;
|
|
606
|
-
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
607
1085
|
}, {
|
|
1086
|
+
result?: string | number | boolean | unknown[] | z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
608
1087
|
errors?: (string | {
|
|
609
1088
|
message: string;
|
|
610
1089
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -624,10 +1103,10 @@ declare const requestEdgehancerResultSchema: z.ZodObject<{
|
|
|
624
1103
|
deepLink?: string | undefined;
|
|
625
1104
|
})[] | undefined;
|
|
626
1105
|
surrogateKeys?: string[] | undefined;
|
|
627
|
-
result?: string | number | boolean | unknown[] | z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
628
1106
|
}>, "many">;
|
|
629
1107
|
}, "strict", z.ZodTypeAny, {
|
|
630
1108
|
results: {
|
|
1109
|
+
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
631
1110
|
errors?: (string | {
|
|
632
1111
|
message: string;
|
|
633
1112
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -647,10 +1126,10 @@ declare const requestEdgehancerResultSchema: z.ZodObject<{
|
|
|
647
1126
|
deepLink?: string | undefined;
|
|
648
1127
|
})[] | undefined;
|
|
649
1128
|
surrogateKeys?: string[] | undefined;
|
|
650
|
-
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
651
1129
|
}[];
|
|
652
1130
|
}, {
|
|
653
1131
|
results: {
|
|
1132
|
+
result?: string | number | boolean | unknown[] | z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
654
1133
|
errors?: (string | {
|
|
655
1134
|
message: string;
|
|
656
1135
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -670,7 +1149,6 @@ declare const requestEdgehancerResultSchema: z.ZodObject<{
|
|
|
670
1149
|
deepLink?: string | undefined;
|
|
671
1150
|
})[] | undefined;
|
|
672
1151
|
surrogateKeys?: string[] | undefined;
|
|
673
|
-
result?: string | number | boolean | unknown[] | z.objectInputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
674
1152
|
}[];
|
|
675
1153
|
}>;
|
|
676
1154
|
type RequestEdgehancerResult = z.infer<typeof requestEdgehancerResultSchema>;
|
|
@@ -689,6 +1167,7 @@ type ConvertBatchResultsToEdgehancerResultOptions<TID, TResultItem extends DataR
|
|
|
689
1167
|
* Given a batch of data resources and their batch-fetch results, convert them into a result that can be returned from a request hook.
|
|
690
1168
|
*/
|
|
691
1169
|
declare function convertBatchResultsToEdgehancerResult<TID, TResultItem extends DataResource>({ batch, batchFetchIds: { invalidBatchIndices, validIdToOriginalIndexMap }, batchResults, resolveIdFromBatchResultFn, knownInvalidErrorMessage, missingBatchResultErrorMessage, }: ConvertBatchResultsToEdgehancerResultOptions<TID, TResultItem>): {
|
|
1170
|
+
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
692
1171
|
errors?: (string | {
|
|
693
1172
|
message: string;
|
|
694
1173
|
subType?: "unpublishedData" | "configuration" | undefined;
|
|
@@ -708,7 +1187,6 @@ declare function convertBatchResultsToEdgehancerResult<TID, TResultItem extends
|
|
|
708
1187
|
deepLink?: string | undefined;
|
|
709
1188
|
})[] | undefined;
|
|
710
1189
|
surrogateKeys?: string[] | undefined;
|
|
711
|
-
result?: string | number | boolean | unknown[] | z.objectOutputType<{}, z.ZodUnknown, "strip"> | undefined;
|
|
712
1190
|
}[];
|
|
713
1191
|
type ResolveBatchIdsResult<TID> = {
|
|
714
1192
|
/** The IDs that are valid that should be fetched */
|
|
@@ -728,6 +1206,404 @@ declare const COLLECTION_DEFAULT_LIMIT = 20;
|
|
|
728
1206
|
declare const COLLECTION_MAX_LIMIT = 50;
|
|
729
1207
|
declare const COLLECTION_DEFAULT_OFFSET = 0;
|
|
730
1208
|
|
|
1209
|
+
declare const createAIDataResourceEditContextSchema: z.ZodObject<{
|
|
1210
|
+
/**
|
|
1211
|
+
* The the data type of the data resource being edited (merged with its data source)
|
|
1212
|
+
* NOTE: this can contain secrets, API keys, etc. Do not directly expose it to the AI agent!
|
|
1213
|
+
* NOTE: this does not include the current value's variables, if any
|
|
1214
|
+
*/
|
|
1215
|
+
mergedDataType: z.ZodType<MergedDataType, z.ZodTypeDef, MergedDataType>;
|
|
1216
|
+
/** Which data source variant is currently active (undefined = published data) */
|
|
1217
|
+
dataSourceVariant: z.ZodOptional<z.ZodType<"unpublished", z.ZodTypeDef, "unpublished">>;
|
|
1218
|
+
/** The edit request details */
|
|
1219
|
+
editRequest: z.ZodObject<{
|
|
1220
|
+
/** The edit instruction from the AI agent */
|
|
1221
|
+
edit: z.ZodString;
|
|
1222
|
+
/** Current value of the data resource's variables (if any) */
|
|
1223
|
+
currentValue: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
|
|
1224
|
+
}, "strip", z.ZodTypeAny, {
|
|
1225
|
+
edit: string;
|
|
1226
|
+
currentValue?: Record<string, string> | undefined;
|
|
1227
|
+
}, {
|
|
1228
|
+
edit: string;
|
|
1229
|
+
currentValue?: Record<string, string> | undefined;
|
|
1230
|
+
}>;
|
|
1231
|
+
/** AI invocation context */
|
|
1232
|
+
invocationContext: z.ZodEnum<["composition", "compositionPattern", "componentPattern", "entry", "entryPattern", "general"]>;
|
|
1233
|
+
/** User ID making the edit */
|
|
1234
|
+
userId: z.ZodString;
|
|
1235
|
+
/** Project ID */
|
|
1236
|
+
projectId: z.ZodString;
|
|
1237
|
+
}, "strict", z.ZodTypeAny, {
|
|
1238
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
1239
|
+
mergedDataType: Omit<{
|
|
1240
|
+
id: string;
|
|
1241
|
+
displayName: string;
|
|
1242
|
+
dataSourceId: string;
|
|
1243
|
+
archetype?: string;
|
|
1244
|
+
allowedOnComponents?: string[];
|
|
1245
|
+
path: string;
|
|
1246
|
+
ttl?: number;
|
|
1247
|
+
purgeKey?: string;
|
|
1248
|
+
badgeIconUrl?: string;
|
|
1249
|
+
headers?: {
|
|
1250
|
+
key: string;
|
|
1251
|
+
value: string;
|
|
1252
|
+
omitIfEmpty?: boolean;
|
|
1253
|
+
}[];
|
|
1254
|
+
parameters?: {
|
|
1255
|
+
key: string;
|
|
1256
|
+
value: string;
|
|
1257
|
+
omitIfEmpty?: boolean;
|
|
1258
|
+
}[];
|
|
1259
|
+
body?: string;
|
|
1260
|
+
method: "GET" | "POST" | "HEAD";
|
|
1261
|
+
variables?: {
|
|
1262
|
+
[key: string]: {
|
|
1263
|
+
displayName?: string;
|
|
1264
|
+
helpText?: string;
|
|
1265
|
+
type?: string;
|
|
1266
|
+
default: string;
|
|
1267
|
+
order?: number;
|
|
1268
|
+
source?: string;
|
|
1269
|
+
};
|
|
1270
|
+
};
|
|
1271
|
+
custom?: {
|
|
1272
|
+
[key: string]: unknown;
|
|
1273
|
+
};
|
|
1274
|
+
}, "path" | "dataSourceId"> & Pick<{
|
|
1275
|
+
id: string;
|
|
1276
|
+
displayName: string;
|
|
1277
|
+
connectorType: string;
|
|
1278
|
+
baseUrl: string;
|
|
1279
|
+
headers?: {
|
|
1280
|
+
key: string;
|
|
1281
|
+
value: string;
|
|
1282
|
+
}[];
|
|
1283
|
+
parameters?: {
|
|
1284
|
+
key: string;
|
|
1285
|
+
value: string;
|
|
1286
|
+
}[];
|
|
1287
|
+
variables?: {
|
|
1288
|
+
[key: string]: {
|
|
1289
|
+
displayName?: string;
|
|
1290
|
+
helpText?: string;
|
|
1291
|
+
type?: string;
|
|
1292
|
+
default: string;
|
|
1293
|
+
order?: number;
|
|
1294
|
+
source?: string;
|
|
1295
|
+
};
|
|
1296
|
+
};
|
|
1297
|
+
localeMapping?: {
|
|
1298
|
+
[key: string]: string;
|
|
1299
|
+
};
|
|
1300
|
+
enableUnpublishedMode?: boolean;
|
|
1301
|
+
customPublic?: {
|
|
1302
|
+
[key: string]: unknown;
|
|
1303
|
+
};
|
|
1304
|
+
custom?: {
|
|
1305
|
+
[key: string]: unknown;
|
|
1306
|
+
};
|
|
1307
|
+
variants?: {
|
|
1308
|
+
unpublished?: {
|
|
1309
|
+
baseUrl: string;
|
|
1310
|
+
headers?: {
|
|
1311
|
+
key: string;
|
|
1312
|
+
value: string;
|
|
1313
|
+
omitIfEmpty?: boolean;
|
|
1314
|
+
}[];
|
|
1315
|
+
parameters?: {
|
|
1316
|
+
key: string;
|
|
1317
|
+
value: string;
|
|
1318
|
+
omitIfEmpty?: boolean;
|
|
1319
|
+
}[];
|
|
1320
|
+
variables?: {
|
|
1321
|
+
[key: string]: {
|
|
1322
|
+
displayName?: string;
|
|
1323
|
+
helpText?: string;
|
|
1324
|
+
type?: string;
|
|
1325
|
+
default: string;
|
|
1326
|
+
order?: number;
|
|
1327
|
+
source?: string;
|
|
1328
|
+
};
|
|
1329
|
+
};
|
|
1330
|
+
};
|
|
1331
|
+
};
|
|
1332
|
+
}, "connectorType" | "customPublic" | "localeMapping" | "enableUnpublishedMode"> & {
|
|
1333
|
+
variants?: Partial<Record<DataSourceVariantsKeys, Omit<NonNullable<_uniformdev_canvas.DataSourceVariantData>, "baseUrl"> & {
|
|
1334
|
+
url: string;
|
|
1335
|
+
}>>;
|
|
1336
|
+
url: string;
|
|
1337
|
+
edgehancer?: CustomEdgehancerDefinition;
|
|
1338
|
+
uiBadgeText?: string;
|
|
1339
|
+
};
|
|
1340
|
+
editRequest: {
|
|
1341
|
+
edit: string;
|
|
1342
|
+
currentValue?: Record<string, string> | undefined;
|
|
1343
|
+
};
|
|
1344
|
+
userId: string;
|
|
1345
|
+
projectId: string;
|
|
1346
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
1347
|
+
}, {
|
|
1348
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
1349
|
+
mergedDataType: Omit<{
|
|
1350
|
+
id: string;
|
|
1351
|
+
displayName: string;
|
|
1352
|
+
dataSourceId: string;
|
|
1353
|
+
archetype?: string;
|
|
1354
|
+
allowedOnComponents?: string[];
|
|
1355
|
+
path: string;
|
|
1356
|
+
ttl?: number;
|
|
1357
|
+
purgeKey?: string;
|
|
1358
|
+
badgeIconUrl?: string;
|
|
1359
|
+
headers?: {
|
|
1360
|
+
key: string;
|
|
1361
|
+
value: string;
|
|
1362
|
+
omitIfEmpty?: boolean;
|
|
1363
|
+
}[];
|
|
1364
|
+
parameters?: {
|
|
1365
|
+
key: string;
|
|
1366
|
+
value: string;
|
|
1367
|
+
omitIfEmpty?: boolean;
|
|
1368
|
+
}[];
|
|
1369
|
+
body?: string;
|
|
1370
|
+
method: "GET" | "POST" | "HEAD";
|
|
1371
|
+
variables?: {
|
|
1372
|
+
[key: string]: {
|
|
1373
|
+
displayName?: string;
|
|
1374
|
+
helpText?: string;
|
|
1375
|
+
type?: string;
|
|
1376
|
+
default: string;
|
|
1377
|
+
order?: number;
|
|
1378
|
+
source?: string;
|
|
1379
|
+
};
|
|
1380
|
+
};
|
|
1381
|
+
custom?: {
|
|
1382
|
+
[key: string]: unknown;
|
|
1383
|
+
};
|
|
1384
|
+
}, "path" | "dataSourceId"> & Pick<{
|
|
1385
|
+
id: string;
|
|
1386
|
+
displayName: string;
|
|
1387
|
+
connectorType: string;
|
|
1388
|
+
baseUrl: string;
|
|
1389
|
+
headers?: {
|
|
1390
|
+
key: string;
|
|
1391
|
+
value: string;
|
|
1392
|
+
}[];
|
|
1393
|
+
parameters?: {
|
|
1394
|
+
key: string;
|
|
1395
|
+
value: string;
|
|
1396
|
+
}[];
|
|
1397
|
+
variables?: {
|
|
1398
|
+
[key: string]: {
|
|
1399
|
+
displayName?: string;
|
|
1400
|
+
helpText?: string;
|
|
1401
|
+
type?: string;
|
|
1402
|
+
default: string;
|
|
1403
|
+
order?: number;
|
|
1404
|
+
source?: string;
|
|
1405
|
+
};
|
|
1406
|
+
};
|
|
1407
|
+
localeMapping?: {
|
|
1408
|
+
[key: string]: string;
|
|
1409
|
+
};
|
|
1410
|
+
enableUnpublishedMode?: boolean;
|
|
1411
|
+
customPublic?: {
|
|
1412
|
+
[key: string]: unknown;
|
|
1413
|
+
};
|
|
1414
|
+
custom?: {
|
|
1415
|
+
[key: string]: unknown;
|
|
1416
|
+
};
|
|
1417
|
+
variants?: {
|
|
1418
|
+
unpublished?: {
|
|
1419
|
+
baseUrl: string;
|
|
1420
|
+
headers?: {
|
|
1421
|
+
key: string;
|
|
1422
|
+
value: string;
|
|
1423
|
+
omitIfEmpty?: boolean;
|
|
1424
|
+
}[];
|
|
1425
|
+
parameters?: {
|
|
1426
|
+
key: string;
|
|
1427
|
+
value: string;
|
|
1428
|
+
omitIfEmpty?: boolean;
|
|
1429
|
+
}[];
|
|
1430
|
+
variables?: {
|
|
1431
|
+
[key: string]: {
|
|
1432
|
+
displayName?: string;
|
|
1433
|
+
helpText?: string;
|
|
1434
|
+
type?: string;
|
|
1435
|
+
default: string;
|
|
1436
|
+
order?: number;
|
|
1437
|
+
source?: string;
|
|
1438
|
+
};
|
|
1439
|
+
};
|
|
1440
|
+
};
|
|
1441
|
+
};
|
|
1442
|
+
}, "connectorType" | "customPublic" | "localeMapping" | "enableUnpublishedMode"> & {
|
|
1443
|
+
variants?: Partial<Record<DataSourceVariantsKeys, Omit<NonNullable<_uniformdev_canvas.DataSourceVariantData>, "baseUrl"> & {
|
|
1444
|
+
url: string;
|
|
1445
|
+
}>>;
|
|
1446
|
+
url: string;
|
|
1447
|
+
edgehancer?: CustomEdgehancerDefinition;
|
|
1448
|
+
uiBadgeText?: string;
|
|
1449
|
+
};
|
|
1450
|
+
editRequest: {
|
|
1451
|
+
edit: string;
|
|
1452
|
+
currentValue?: Record<string, string> | undefined;
|
|
1453
|
+
};
|
|
1454
|
+
userId: string;
|
|
1455
|
+
projectId: string;
|
|
1456
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
1457
|
+
}>;
|
|
1458
|
+
type CreateAIDataResourceEditContext = z.infer<typeof createAIDataResourceEditContextSchema>;
|
|
1459
|
+
declare const createAIDataResourceEditResultSchema: z.ZodObject<{
|
|
1460
|
+
outputJsonSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
|
|
1461
|
+
instructions: z.ZodString;
|
|
1462
|
+
}, "strict", z.ZodTypeAny, {
|
|
1463
|
+
outputJsonSchema: Record<string, any>;
|
|
1464
|
+
instructions: string;
|
|
1465
|
+
}, {
|
|
1466
|
+
outputJsonSchema: Record<string, any>;
|
|
1467
|
+
instructions: string;
|
|
1468
|
+
}>;
|
|
1469
|
+
type CreateAIDataResourceEditResult = z.infer<typeof createAIDataResourceEditResultSchema>;
|
|
1470
|
+
/**
|
|
1471
|
+
* Shape of a hook function that is invoked to create the prompt and output schema for an AI edit to a data resource.
|
|
1472
|
+
*
|
|
1473
|
+
* This hook is called when AI needs to edit the content of a data resource. It should return instructions
|
|
1474
|
+
* for the AI and a JSON schema describing the expected output format.
|
|
1475
|
+
*
|
|
1476
|
+
* NOTE: the instructions returned by this hook are part of a larger system editing prompt. Only describe how to edit
|
|
1477
|
+
* the data resource content itself, not general editing instructions.
|
|
1478
|
+
*/
|
|
1479
|
+
type CreateAIDataResourceEditHookFn = (context: CreateAIDataResourceEditContext) => Promise<CreateAIDataResourceEditResult>;
|
|
1480
|
+
|
|
1481
|
+
declare const createAIEditContextSchema: z.ZodObject<{
|
|
1482
|
+
editRequest: z.ZodObject<{
|
|
1483
|
+
edit: z.ZodString;
|
|
1484
|
+
currentValue: z.ZodOptional<z.ZodUnknown>;
|
|
1485
|
+
projectGuidance: z.ZodOptional<z.ZodString>;
|
|
1486
|
+
componentGuidance: z.ZodOptional<z.ZodString>;
|
|
1487
|
+
audienceGuidance: z.ZodOptional<z.ZodString>;
|
|
1488
|
+
propertyDefinition: z.ZodObject<{
|
|
1489
|
+
id: z.ZodString;
|
|
1490
|
+
name: z.ZodString;
|
|
1491
|
+
type: z.ZodString;
|
|
1492
|
+
guidance: z.ZodOptional<z.ZodString>;
|
|
1493
|
+
typeConfig: z.ZodOptional<z.ZodUnknown>;
|
|
1494
|
+
}, "strip", z.ZodTypeAny, {
|
|
1495
|
+
type: string;
|
|
1496
|
+
id: string;
|
|
1497
|
+
name: string;
|
|
1498
|
+
guidance?: string | undefined;
|
|
1499
|
+
typeConfig?: unknown;
|
|
1500
|
+
}, {
|
|
1501
|
+
type: string;
|
|
1502
|
+
id: string;
|
|
1503
|
+
name: string;
|
|
1504
|
+
guidance?: string | undefined;
|
|
1505
|
+
typeConfig?: unknown;
|
|
1506
|
+
}>;
|
|
1507
|
+
outputLocale: z.ZodOptional<z.ZodString>;
|
|
1508
|
+
documentContext: z.ZodOptional<z.ZodString>;
|
|
1509
|
+
}, "strip", z.ZodTypeAny, {
|
|
1510
|
+
edit: string;
|
|
1511
|
+
propertyDefinition: {
|
|
1512
|
+
type: string;
|
|
1513
|
+
id: string;
|
|
1514
|
+
name: string;
|
|
1515
|
+
guidance?: string | undefined;
|
|
1516
|
+
typeConfig?: unknown;
|
|
1517
|
+
};
|
|
1518
|
+
currentValue?: unknown;
|
|
1519
|
+
projectGuidance?: string | undefined;
|
|
1520
|
+
componentGuidance?: string | undefined;
|
|
1521
|
+
audienceGuidance?: string | undefined;
|
|
1522
|
+
outputLocale?: string | undefined;
|
|
1523
|
+
documentContext?: string | undefined;
|
|
1524
|
+
}, {
|
|
1525
|
+
edit: string;
|
|
1526
|
+
propertyDefinition: {
|
|
1527
|
+
type: string;
|
|
1528
|
+
id: string;
|
|
1529
|
+
name: string;
|
|
1530
|
+
guidance?: string | undefined;
|
|
1531
|
+
typeConfig?: unknown;
|
|
1532
|
+
};
|
|
1533
|
+
currentValue?: unknown;
|
|
1534
|
+
projectGuidance?: string | undefined;
|
|
1535
|
+
componentGuidance?: string | undefined;
|
|
1536
|
+
audienceGuidance?: string | undefined;
|
|
1537
|
+
outputLocale?: string | undefined;
|
|
1538
|
+
documentContext?: string | undefined;
|
|
1539
|
+
}>;
|
|
1540
|
+
invocationContext: z.ZodEnum<["composition", "compositionPattern", "componentPattern", "entry", "entryPattern", "general"]>;
|
|
1541
|
+
userId: z.ZodString;
|
|
1542
|
+
currentLocale: z.ZodOptional<z.ZodString>;
|
|
1543
|
+
projectId: z.ZodString;
|
|
1544
|
+
}, "strict", z.ZodTypeAny, {
|
|
1545
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
1546
|
+
editRequest: {
|
|
1547
|
+
edit: string;
|
|
1548
|
+
propertyDefinition: {
|
|
1549
|
+
type: string;
|
|
1550
|
+
id: string;
|
|
1551
|
+
name: string;
|
|
1552
|
+
guidance?: string | undefined;
|
|
1553
|
+
typeConfig?: unknown;
|
|
1554
|
+
};
|
|
1555
|
+
currentValue?: unknown;
|
|
1556
|
+
projectGuidance?: string | undefined;
|
|
1557
|
+
componentGuidance?: string | undefined;
|
|
1558
|
+
audienceGuidance?: string | undefined;
|
|
1559
|
+
outputLocale?: string | undefined;
|
|
1560
|
+
documentContext?: string | undefined;
|
|
1561
|
+
};
|
|
1562
|
+
userId: string;
|
|
1563
|
+
projectId: string;
|
|
1564
|
+
currentLocale?: string | undefined;
|
|
1565
|
+
}, {
|
|
1566
|
+
invocationContext: "composition" | "compositionPattern" | "componentPattern" | "entry" | "entryPattern" | "general";
|
|
1567
|
+
editRequest: {
|
|
1568
|
+
edit: string;
|
|
1569
|
+
propertyDefinition: {
|
|
1570
|
+
type: string;
|
|
1571
|
+
id: string;
|
|
1572
|
+
name: string;
|
|
1573
|
+
guidance?: string | undefined;
|
|
1574
|
+
typeConfig?: unknown;
|
|
1575
|
+
};
|
|
1576
|
+
currentValue?: unknown;
|
|
1577
|
+
projectGuidance?: string | undefined;
|
|
1578
|
+
componentGuidance?: string | undefined;
|
|
1579
|
+
audienceGuidance?: string | undefined;
|
|
1580
|
+
outputLocale?: string | undefined;
|
|
1581
|
+
documentContext?: string | undefined;
|
|
1582
|
+
};
|
|
1583
|
+
userId: string;
|
|
1584
|
+
projectId: string;
|
|
1585
|
+
currentLocale?: string | undefined;
|
|
1586
|
+
}>;
|
|
1587
|
+
type CreateAIEditContext = z.infer<typeof createAIEditContextSchema>;
|
|
1588
|
+
declare const createAIEditResultSchema: z.ZodObject<{
|
|
1589
|
+
outputJsonSchema: z.ZodRecord<z.ZodString, z.ZodAny>;
|
|
1590
|
+
instructions: z.ZodString;
|
|
1591
|
+
}, "strict", z.ZodTypeAny, {
|
|
1592
|
+
outputJsonSchema: Record<string, any>;
|
|
1593
|
+
instructions: string;
|
|
1594
|
+
}, {
|
|
1595
|
+
outputJsonSchema: Record<string, any>;
|
|
1596
|
+
instructions: string;
|
|
1597
|
+
}>;
|
|
1598
|
+
type CreateAIEditResult = z.infer<typeof createAIEditResultSchema>;
|
|
1599
|
+
/**
|
|
1600
|
+
* Shape of a hook function that is invoked to create the prompt and output schema for an AI edit to a custom property type.
|
|
1601
|
+
|
|
1602
|
+
* NOTE: the prompt returned by this hook is part of a larger system editing prompt. Only describe how to edit
|
|
1603
|
+
* the custom property type itself.
|
|
1604
|
+
*/
|
|
1605
|
+
type CreateAIEditHookFn = (context: CreateAIEditContext) => Promise<CreateAIEditResult>;
|
|
1606
|
+
|
|
731
1607
|
declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
732
1608
|
id: z.ZodString;
|
|
733
1609
|
displayName: z.ZodString;
|
|
@@ -741,12 +1617,12 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
741
1617
|
value: z.ZodString;
|
|
742
1618
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
743
1619
|
}, "strip", z.ZodTypeAny, {
|
|
744
|
-
key: string;
|
|
745
1620
|
value: string;
|
|
1621
|
+
key: string;
|
|
746
1622
|
omitIfEmpty?: boolean | undefined;
|
|
747
1623
|
}, {
|
|
748
|
-
key: string;
|
|
749
1624
|
value: string;
|
|
1625
|
+
key: string;
|
|
750
1626
|
omitIfEmpty?: boolean | undefined;
|
|
751
1627
|
}>, "many">>;
|
|
752
1628
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -754,12 +1630,12 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
754
1630
|
value: z.ZodString;
|
|
755
1631
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
756
1632
|
}, "strip", z.ZodTypeAny, {
|
|
757
|
-
key: string;
|
|
758
1633
|
value: string;
|
|
1634
|
+
key: string;
|
|
759
1635
|
omitIfEmpty?: boolean | undefined;
|
|
760
1636
|
}, {
|
|
761
|
-
key: string;
|
|
762
1637
|
value: string;
|
|
1638
|
+
key: string;
|
|
763
1639
|
omitIfEmpty?: boolean | undefined;
|
|
764
1640
|
}>, "many">>;
|
|
765
1641
|
body: z.ZodOptional<z.ZodString>;
|
|
@@ -794,12 +1670,18 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
794
1670
|
edgehancer: z.ZodOptional<z.ZodObject<{
|
|
795
1671
|
preRequest: z.ZodOptional<z.ZodString>;
|
|
796
1672
|
request: z.ZodOptional<z.ZodString>;
|
|
1673
|
+
createAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
1674
|
+
afterAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
797
1675
|
}, "strip", z.ZodTypeAny, {
|
|
798
1676
|
preRequest?: string | undefined;
|
|
799
1677
|
request?: string | undefined;
|
|
1678
|
+
createAIDataResourceEdit?: string | undefined;
|
|
1679
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
800
1680
|
}, {
|
|
801
1681
|
preRequest?: string | undefined;
|
|
802
1682
|
request?: string | undefined;
|
|
1683
|
+
createAIDataResourceEdit?: string | undefined;
|
|
1684
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
803
1685
|
}>>;
|
|
804
1686
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
805
1687
|
variants: z.ZodOptional<z.ZodObject<{
|
|
@@ -809,12 +1691,12 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
809
1691
|
value: z.ZodString;
|
|
810
1692
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
811
1693
|
}, "strip", z.ZodTypeAny, {
|
|
812
|
-
key: string;
|
|
813
1694
|
value: string;
|
|
1695
|
+
key: string;
|
|
814
1696
|
omitIfEmpty?: boolean | undefined;
|
|
815
1697
|
}, {
|
|
816
|
-
key: string;
|
|
817
1698
|
value: string;
|
|
1699
|
+
key: string;
|
|
818
1700
|
omitIfEmpty?: boolean | undefined;
|
|
819
1701
|
}>, "many">>;
|
|
820
1702
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -822,12 +1704,12 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
822
1704
|
value: z.ZodString;
|
|
823
1705
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
824
1706
|
}, "strip", z.ZodTypeAny, {
|
|
825
|
-
key: string;
|
|
826
1707
|
value: string;
|
|
1708
|
+
key: string;
|
|
827
1709
|
omitIfEmpty?: boolean | undefined;
|
|
828
1710
|
}, {
|
|
829
|
-
key: string;
|
|
830
1711
|
value: string;
|
|
1712
|
+
key: string;
|
|
831
1713
|
omitIfEmpty?: boolean | undefined;
|
|
832
1714
|
}>, "many">>;
|
|
833
1715
|
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -854,13 +1736,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
854
1736
|
}>>>;
|
|
855
1737
|
}, "strip", z.ZodTypeAny, {
|
|
856
1738
|
headers?: {
|
|
857
|
-
key: string;
|
|
858
1739
|
value: string;
|
|
1740
|
+
key: string;
|
|
859
1741
|
omitIfEmpty?: boolean | undefined;
|
|
860
1742
|
}[] | undefined;
|
|
861
1743
|
parameters?: {
|
|
862
|
-
key: string;
|
|
863
1744
|
value: string;
|
|
1745
|
+
key: string;
|
|
864
1746
|
omitIfEmpty?: boolean | undefined;
|
|
865
1747
|
}[] | undefined;
|
|
866
1748
|
variables?: Record<string, {
|
|
@@ -873,13 +1755,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
873
1755
|
}> | undefined;
|
|
874
1756
|
}, {
|
|
875
1757
|
headers?: {
|
|
876
|
-
key: string;
|
|
877
1758
|
value: string;
|
|
1759
|
+
key: string;
|
|
878
1760
|
omitIfEmpty?: boolean | undefined;
|
|
879
1761
|
}[] | undefined;
|
|
880
1762
|
parameters?: {
|
|
881
|
-
key: string;
|
|
882
1763
|
value: string;
|
|
1764
|
+
key: string;
|
|
883
1765
|
omitIfEmpty?: boolean | undefined;
|
|
884
1766
|
}[] | undefined;
|
|
885
1767
|
variables?: Record<string, {
|
|
@@ -900,13 +1782,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
900
1782
|
}, "strip", z.ZodTypeAny, {
|
|
901
1783
|
unpublished?: ({
|
|
902
1784
|
headers?: {
|
|
903
|
-
key: string;
|
|
904
1785
|
value: string;
|
|
1786
|
+
key: string;
|
|
905
1787
|
omitIfEmpty?: boolean | undefined;
|
|
906
1788
|
}[] | undefined;
|
|
907
1789
|
parameters?: {
|
|
908
|
-
key: string;
|
|
909
1790
|
value: string;
|
|
1791
|
+
key: string;
|
|
910
1792
|
omitIfEmpty?: boolean | undefined;
|
|
911
1793
|
}[] | undefined;
|
|
912
1794
|
variables?: Record<string, {
|
|
@@ -923,13 +1805,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
923
1805
|
}, {
|
|
924
1806
|
unpublished?: ({
|
|
925
1807
|
headers?: {
|
|
926
|
-
key: string;
|
|
927
1808
|
value: string;
|
|
1809
|
+
key: string;
|
|
928
1810
|
omitIfEmpty?: boolean | undefined;
|
|
929
1811
|
}[] | undefined;
|
|
930
1812
|
parameters?: {
|
|
931
|
-
key: string;
|
|
932
1813
|
value: string;
|
|
1814
|
+
key: string;
|
|
933
1815
|
omitIfEmpty?: boolean | undefined;
|
|
934
1816
|
}[] | undefined;
|
|
935
1817
|
variables?: Record<string, {
|
|
@@ -945,19 +1827,19 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
945
1827
|
}) | undefined;
|
|
946
1828
|
}>>;
|
|
947
1829
|
enableUnpublishedMode: z.ZodOptional<z.ZodBoolean>;
|
|
948
|
-
}, "
|
|
1830
|
+
}, "id" | "displayName" | "variables" | "allowedOnComponents" | "badgeIconUrl" | "purgeKey" | "edgehancer">, "strip", z.ZodTypeAny, {
|
|
949
1831
|
url: string;
|
|
950
1832
|
connectorType: string;
|
|
951
1833
|
method: "GET" | "POST" | "HEAD";
|
|
952
1834
|
custom?: Record<string, unknown> | undefined;
|
|
953
1835
|
headers?: {
|
|
954
|
-
key: string;
|
|
955
1836
|
value: string;
|
|
1837
|
+
key: string;
|
|
956
1838
|
omitIfEmpty?: boolean | undefined;
|
|
957
1839
|
}[] | undefined;
|
|
958
1840
|
parameters?: {
|
|
959
|
-
key: string;
|
|
960
1841
|
value: string;
|
|
1842
|
+
key: string;
|
|
961
1843
|
omitIfEmpty?: boolean | undefined;
|
|
962
1844
|
}[] | undefined;
|
|
963
1845
|
archetype?: string | undefined;
|
|
@@ -969,13 +1851,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
969
1851
|
variants?: {
|
|
970
1852
|
unpublished?: ({
|
|
971
1853
|
headers?: {
|
|
972
|
-
key: string;
|
|
973
1854
|
value: string;
|
|
1855
|
+
key: string;
|
|
974
1856
|
omitIfEmpty?: boolean | undefined;
|
|
975
1857
|
}[] | undefined;
|
|
976
1858
|
parameters?: {
|
|
977
|
-
key: string;
|
|
978
1859
|
value: string;
|
|
1860
|
+
key: string;
|
|
979
1861
|
omitIfEmpty?: boolean | undefined;
|
|
980
1862
|
}[] | undefined;
|
|
981
1863
|
variables?: Record<string, {
|
|
@@ -997,13 +1879,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
997
1879
|
method: "GET" | "POST" | "HEAD";
|
|
998
1880
|
custom?: Record<string, unknown> | undefined;
|
|
999
1881
|
headers?: {
|
|
1000
|
-
key: string;
|
|
1001
1882
|
value: string;
|
|
1883
|
+
key: string;
|
|
1002
1884
|
omitIfEmpty?: boolean | undefined;
|
|
1003
1885
|
}[] | undefined;
|
|
1004
1886
|
parameters?: {
|
|
1005
|
-
key: string;
|
|
1006
1887
|
value: string;
|
|
1888
|
+
key: string;
|
|
1007
1889
|
omitIfEmpty?: boolean | undefined;
|
|
1008
1890
|
}[] | undefined;
|
|
1009
1891
|
archetype?: string | undefined;
|
|
@@ -1015,13 +1897,13 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
1015
1897
|
variants?: {
|
|
1016
1898
|
unpublished?: ({
|
|
1017
1899
|
headers?: {
|
|
1018
|
-
key: string;
|
|
1019
1900
|
value: string;
|
|
1901
|
+
key: string;
|
|
1020
1902
|
omitIfEmpty?: boolean | undefined;
|
|
1021
1903
|
}[] | undefined;
|
|
1022
1904
|
parameters?: {
|
|
1023
|
-
key: string;
|
|
1024
1905
|
value: string;
|
|
1906
|
+
key: string;
|
|
1025
1907
|
omitIfEmpty?: boolean | undefined;
|
|
1026
1908
|
}[] | undefined;
|
|
1027
1909
|
variables?: Record<string, {
|
|
@@ -1119,12 +2001,12 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1119
2001
|
value: z.ZodString;
|
|
1120
2002
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1121
2003
|
}, "strip", z.ZodTypeAny, {
|
|
1122
|
-
key: string;
|
|
1123
2004
|
value: string;
|
|
2005
|
+
key: string;
|
|
1124
2006
|
omitIfEmpty?: boolean | undefined;
|
|
1125
2007
|
}, {
|
|
1126
|
-
key: string;
|
|
1127
2008
|
value: string;
|
|
2009
|
+
key: string;
|
|
1128
2010
|
omitIfEmpty?: boolean | undefined;
|
|
1129
2011
|
}>, "many">>;
|
|
1130
2012
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -1132,12 +2014,12 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1132
2014
|
value: z.ZodString;
|
|
1133
2015
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1134
2016
|
}, "strip", z.ZodTypeAny, {
|
|
1135
|
-
key: string;
|
|
1136
2017
|
value: string;
|
|
2018
|
+
key: string;
|
|
1137
2019
|
omitIfEmpty?: boolean | undefined;
|
|
1138
2020
|
}, {
|
|
1139
|
-
key: string;
|
|
1140
2021
|
value: string;
|
|
2022
|
+
key: string;
|
|
1141
2023
|
omitIfEmpty?: boolean | undefined;
|
|
1142
2024
|
}>, "many">>;
|
|
1143
2025
|
body: z.ZodOptional<z.ZodString>;
|
|
@@ -1172,12 +2054,18 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1172
2054
|
edgehancer: z.ZodOptional<z.ZodObject<{
|
|
1173
2055
|
preRequest: z.ZodOptional<z.ZodString>;
|
|
1174
2056
|
request: z.ZodOptional<z.ZodString>;
|
|
2057
|
+
createAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
2058
|
+
afterAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
1175
2059
|
}, "strip", z.ZodTypeAny, {
|
|
1176
2060
|
preRequest?: string | undefined;
|
|
1177
2061
|
request?: string | undefined;
|
|
2062
|
+
createAIDataResourceEdit?: string | undefined;
|
|
2063
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
1178
2064
|
}, {
|
|
1179
2065
|
preRequest?: string | undefined;
|
|
1180
2066
|
request?: string | undefined;
|
|
2067
|
+
createAIDataResourceEdit?: string | undefined;
|
|
2068
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
1181
2069
|
}>>;
|
|
1182
2070
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
1183
2071
|
variants: z.ZodOptional<z.ZodObject<{
|
|
@@ -1187,12 +2075,12 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1187
2075
|
value: z.ZodString;
|
|
1188
2076
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1189
2077
|
}, "strip", z.ZodTypeAny, {
|
|
1190
|
-
key: string;
|
|
1191
2078
|
value: string;
|
|
2079
|
+
key: string;
|
|
1192
2080
|
omitIfEmpty?: boolean | undefined;
|
|
1193
2081
|
}, {
|
|
1194
|
-
key: string;
|
|
1195
2082
|
value: string;
|
|
2083
|
+
key: string;
|
|
1196
2084
|
omitIfEmpty?: boolean | undefined;
|
|
1197
2085
|
}>, "many">>;
|
|
1198
2086
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -1200,12 +2088,12 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1200
2088
|
value: z.ZodString;
|
|
1201
2089
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1202
2090
|
}, "strip", z.ZodTypeAny, {
|
|
1203
|
-
key: string;
|
|
1204
2091
|
value: string;
|
|
2092
|
+
key: string;
|
|
1205
2093
|
omitIfEmpty?: boolean | undefined;
|
|
1206
2094
|
}, {
|
|
1207
|
-
key: string;
|
|
1208
2095
|
value: string;
|
|
2096
|
+
key: string;
|
|
1209
2097
|
omitIfEmpty?: boolean | undefined;
|
|
1210
2098
|
}>, "many">>;
|
|
1211
2099
|
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -1232,13 +2120,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1232
2120
|
}>>>;
|
|
1233
2121
|
}, "strip", z.ZodTypeAny, {
|
|
1234
2122
|
headers?: {
|
|
1235
|
-
key: string;
|
|
1236
2123
|
value: string;
|
|
2124
|
+
key: string;
|
|
1237
2125
|
omitIfEmpty?: boolean | undefined;
|
|
1238
2126
|
}[] | undefined;
|
|
1239
2127
|
parameters?: {
|
|
1240
|
-
key: string;
|
|
1241
2128
|
value: string;
|
|
2129
|
+
key: string;
|
|
1242
2130
|
omitIfEmpty?: boolean | undefined;
|
|
1243
2131
|
}[] | undefined;
|
|
1244
2132
|
variables?: Record<string, {
|
|
@@ -1251,13 +2139,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1251
2139
|
}> | undefined;
|
|
1252
2140
|
}, {
|
|
1253
2141
|
headers?: {
|
|
1254
|
-
key: string;
|
|
1255
2142
|
value: string;
|
|
2143
|
+
key: string;
|
|
1256
2144
|
omitIfEmpty?: boolean | undefined;
|
|
1257
2145
|
}[] | undefined;
|
|
1258
2146
|
parameters?: {
|
|
1259
|
-
key: string;
|
|
1260
2147
|
value: string;
|
|
2148
|
+
key: string;
|
|
1261
2149
|
omitIfEmpty?: boolean | undefined;
|
|
1262
2150
|
}[] | undefined;
|
|
1263
2151
|
variables?: Record<string, {
|
|
@@ -1278,13 +2166,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1278
2166
|
}, "strip", z.ZodTypeAny, {
|
|
1279
2167
|
unpublished?: ({
|
|
1280
2168
|
headers?: {
|
|
1281
|
-
key: string;
|
|
1282
2169
|
value: string;
|
|
2170
|
+
key: string;
|
|
1283
2171
|
omitIfEmpty?: boolean | undefined;
|
|
1284
2172
|
}[] | undefined;
|
|
1285
2173
|
parameters?: {
|
|
1286
|
-
key: string;
|
|
1287
2174
|
value: string;
|
|
2175
|
+
key: string;
|
|
1288
2176
|
omitIfEmpty?: boolean | undefined;
|
|
1289
2177
|
}[] | undefined;
|
|
1290
2178
|
variables?: Record<string, {
|
|
@@ -1301,13 +2189,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1301
2189
|
}, {
|
|
1302
2190
|
unpublished?: ({
|
|
1303
2191
|
headers?: {
|
|
1304
|
-
key: string;
|
|
1305
2192
|
value: string;
|
|
2193
|
+
key: string;
|
|
1306
2194
|
omitIfEmpty?: boolean | undefined;
|
|
1307
2195
|
}[] | undefined;
|
|
1308
2196
|
parameters?: {
|
|
1309
|
-
key: string;
|
|
1310
2197
|
value: string;
|
|
2198
|
+
key: string;
|
|
1311
2199
|
omitIfEmpty?: boolean | undefined;
|
|
1312
2200
|
}[] | undefined;
|
|
1313
2201
|
variables?: Record<string, {
|
|
@@ -1323,19 +2211,19 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1323
2211
|
}) | undefined;
|
|
1324
2212
|
}>>;
|
|
1325
2213
|
enableUnpublishedMode: z.ZodOptional<z.ZodBoolean>;
|
|
1326
|
-
}, "
|
|
2214
|
+
}, "id" | "displayName" | "variables" | "allowedOnComponents" | "badgeIconUrl" | "purgeKey" | "edgehancer">, "strip", z.ZodTypeAny, {
|
|
1327
2215
|
url: string;
|
|
1328
2216
|
connectorType: string;
|
|
1329
2217
|
method: "GET" | "POST" | "HEAD";
|
|
1330
2218
|
custom?: Record<string, unknown> | undefined;
|
|
1331
2219
|
headers?: {
|
|
1332
|
-
key: string;
|
|
1333
2220
|
value: string;
|
|
2221
|
+
key: string;
|
|
1334
2222
|
omitIfEmpty?: boolean | undefined;
|
|
1335
2223
|
}[] | undefined;
|
|
1336
2224
|
parameters?: {
|
|
1337
|
-
key: string;
|
|
1338
2225
|
value: string;
|
|
2226
|
+
key: string;
|
|
1339
2227
|
omitIfEmpty?: boolean | undefined;
|
|
1340
2228
|
}[] | undefined;
|
|
1341
2229
|
archetype?: string | undefined;
|
|
@@ -1347,13 +2235,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1347
2235
|
variants?: {
|
|
1348
2236
|
unpublished?: ({
|
|
1349
2237
|
headers?: {
|
|
1350
|
-
key: string;
|
|
1351
2238
|
value: string;
|
|
2239
|
+
key: string;
|
|
1352
2240
|
omitIfEmpty?: boolean | undefined;
|
|
1353
2241
|
}[] | undefined;
|
|
1354
2242
|
parameters?: {
|
|
1355
|
-
key: string;
|
|
1356
2243
|
value: string;
|
|
2244
|
+
key: string;
|
|
1357
2245
|
omitIfEmpty?: boolean | undefined;
|
|
1358
2246
|
}[] | undefined;
|
|
1359
2247
|
variables?: Record<string, {
|
|
@@ -1375,13 +2263,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1375
2263
|
method: "GET" | "POST" | "HEAD";
|
|
1376
2264
|
custom?: Record<string, unknown> | undefined;
|
|
1377
2265
|
headers?: {
|
|
1378
|
-
key: string;
|
|
1379
2266
|
value: string;
|
|
2267
|
+
key: string;
|
|
1380
2268
|
omitIfEmpty?: boolean | undefined;
|
|
1381
2269
|
}[] | undefined;
|
|
1382
2270
|
parameters?: {
|
|
1383
|
-
key: string;
|
|
1384
2271
|
value: string;
|
|
2272
|
+
key: string;
|
|
1385
2273
|
omitIfEmpty?: boolean | undefined;
|
|
1386
2274
|
}[] | undefined;
|
|
1387
2275
|
archetype?: string | undefined;
|
|
@@ -1393,13 +2281,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1393
2281
|
variants?: {
|
|
1394
2282
|
unpublished?: ({
|
|
1395
2283
|
headers?: {
|
|
1396
|
-
key: string;
|
|
1397
2284
|
value: string;
|
|
2285
|
+
key: string;
|
|
1398
2286
|
omitIfEmpty?: boolean | undefined;
|
|
1399
2287
|
}[] | undefined;
|
|
1400
2288
|
parameters?: {
|
|
1401
|
-
key: string;
|
|
1402
2289
|
value: string;
|
|
2290
|
+
key: string;
|
|
1403
2291
|
omitIfEmpty?: boolean | undefined;
|
|
1404
2292
|
}[] | undefined;
|
|
1405
2293
|
variables?: Record<string, {
|
|
@@ -1423,13 +2311,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1423
2311
|
method: "GET" | "POST" | "HEAD";
|
|
1424
2312
|
custom?: Record<string, unknown> | undefined;
|
|
1425
2313
|
headers?: {
|
|
1426
|
-
key: string;
|
|
1427
2314
|
value: string;
|
|
2315
|
+
key: string;
|
|
1428
2316
|
omitIfEmpty?: boolean | undefined;
|
|
1429
2317
|
}[] | undefined;
|
|
1430
2318
|
parameters?: {
|
|
1431
|
-
key: string;
|
|
1432
2319
|
value: string;
|
|
2320
|
+
key: string;
|
|
1433
2321
|
omitIfEmpty?: boolean | undefined;
|
|
1434
2322
|
}[] | undefined;
|
|
1435
2323
|
archetype?: string | undefined;
|
|
@@ -1441,13 +2329,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1441
2329
|
variants?: {
|
|
1442
2330
|
unpublished?: ({
|
|
1443
2331
|
headers?: {
|
|
1444
|
-
key: string;
|
|
1445
2332
|
value: string;
|
|
2333
|
+
key: string;
|
|
1446
2334
|
omitIfEmpty?: boolean | undefined;
|
|
1447
2335
|
}[] | undefined;
|
|
1448
2336
|
parameters?: {
|
|
1449
|
-
key: string;
|
|
1450
2337
|
value: string;
|
|
2338
|
+
key: string;
|
|
1451
2339
|
omitIfEmpty?: boolean | undefined;
|
|
1452
2340
|
}[] | undefined;
|
|
1453
2341
|
variables?: Record<string, {
|
|
@@ -1489,13 +2377,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1489
2377
|
method: "GET" | "POST" | "HEAD";
|
|
1490
2378
|
custom?: Record<string, unknown> | undefined;
|
|
1491
2379
|
headers?: {
|
|
1492
|
-
key: string;
|
|
1493
2380
|
value: string;
|
|
2381
|
+
key: string;
|
|
1494
2382
|
omitIfEmpty?: boolean | undefined;
|
|
1495
2383
|
}[] | undefined;
|
|
1496
2384
|
parameters?: {
|
|
1497
|
-
key: string;
|
|
1498
2385
|
value: string;
|
|
2386
|
+
key: string;
|
|
1499
2387
|
omitIfEmpty?: boolean | undefined;
|
|
1500
2388
|
}[] | undefined;
|
|
1501
2389
|
archetype?: string | undefined;
|
|
@@ -1507,13 +2395,13 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
1507
2395
|
variants?: {
|
|
1508
2396
|
unpublished?: ({
|
|
1509
2397
|
headers?: {
|
|
1510
|
-
key: string;
|
|
1511
2398
|
value: string;
|
|
2399
|
+
key: string;
|
|
1512
2400
|
omitIfEmpty?: boolean | undefined;
|
|
1513
2401
|
}[] | undefined;
|
|
1514
2402
|
parameters?: {
|
|
1515
|
-
key: string;
|
|
1516
2403
|
value: string;
|
|
2404
|
+
key: string;
|
|
1517
2405
|
omitIfEmpty?: boolean | undefined;
|
|
1518
2406
|
}[] | undefined;
|
|
1519
2407
|
variables?: Record<string, {
|
|
@@ -1612,12 +2500,12 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1612
2500
|
value: z.ZodString;
|
|
1613
2501
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1614
2502
|
}, "strip", z.ZodTypeAny, {
|
|
1615
|
-
key: string;
|
|
1616
2503
|
value: string;
|
|
2504
|
+
key: string;
|
|
1617
2505
|
omitIfEmpty?: boolean | undefined;
|
|
1618
2506
|
}, {
|
|
1619
|
-
key: string;
|
|
1620
2507
|
value: string;
|
|
2508
|
+
key: string;
|
|
1621
2509
|
omitIfEmpty?: boolean | undefined;
|
|
1622
2510
|
}>, "many">>;
|
|
1623
2511
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -1625,12 +2513,12 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1625
2513
|
value: z.ZodString;
|
|
1626
2514
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1627
2515
|
}, "strip", z.ZodTypeAny, {
|
|
1628
|
-
key: string;
|
|
1629
2516
|
value: string;
|
|
2517
|
+
key: string;
|
|
1630
2518
|
omitIfEmpty?: boolean | undefined;
|
|
1631
2519
|
}, {
|
|
1632
|
-
key: string;
|
|
1633
2520
|
value: string;
|
|
2521
|
+
key: string;
|
|
1634
2522
|
omitIfEmpty?: boolean | undefined;
|
|
1635
2523
|
}>, "many">>;
|
|
1636
2524
|
body: z.ZodOptional<z.ZodString>;
|
|
@@ -1665,12 +2553,18 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1665
2553
|
edgehancer: z.ZodOptional<z.ZodObject<{
|
|
1666
2554
|
preRequest: z.ZodOptional<z.ZodString>;
|
|
1667
2555
|
request: z.ZodOptional<z.ZodString>;
|
|
2556
|
+
createAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
2557
|
+
afterAIDataResourceEdit: z.ZodOptional<z.ZodString>;
|
|
1668
2558
|
}, "strip", z.ZodTypeAny, {
|
|
1669
2559
|
preRequest?: string | undefined;
|
|
1670
2560
|
request?: string | undefined;
|
|
2561
|
+
createAIDataResourceEdit?: string | undefined;
|
|
2562
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
1671
2563
|
}, {
|
|
1672
2564
|
preRequest?: string | undefined;
|
|
1673
2565
|
request?: string | undefined;
|
|
2566
|
+
createAIDataResourceEdit?: string | undefined;
|
|
2567
|
+
afterAIDataResourceEdit?: string | undefined;
|
|
1674
2568
|
}>>;
|
|
1675
2569
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
1676
2570
|
variants: z.ZodOptional<z.ZodObject<{
|
|
@@ -1680,12 +2574,12 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1680
2574
|
value: z.ZodString;
|
|
1681
2575
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1682
2576
|
}, "strip", z.ZodTypeAny, {
|
|
1683
|
-
key: string;
|
|
1684
2577
|
value: string;
|
|
2578
|
+
key: string;
|
|
1685
2579
|
omitIfEmpty?: boolean | undefined;
|
|
1686
2580
|
}, {
|
|
1687
|
-
key: string;
|
|
1688
2581
|
value: string;
|
|
2582
|
+
key: string;
|
|
1689
2583
|
omitIfEmpty?: boolean | undefined;
|
|
1690
2584
|
}>, "many">>;
|
|
1691
2585
|
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
@@ -1693,12 +2587,12 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1693
2587
|
value: z.ZodString;
|
|
1694
2588
|
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1695
2589
|
}, "strip", z.ZodTypeAny, {
|
|
1696
|
-
key: string;
|
|
1697
2590
|
value: string;
|
|
2591
|
+
key: string;
|
|
1698
2592
|
omitIfEmpty?: boolean | undefined;
|
|
1699
2593
|
}, {
|
|
1700
|
-
key: string;
|
|
1701
2594
|
value: string;
|
|
2595
|
+
key: string;
|
|
1702
2596
|
omitIfEmpty?: boolean | undefined;
|
|
1703
2597
|
}>, "many">>;
|
|
1704
2598
|
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
@@ -1725,13 +2619,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1725
2619
|
}>>>;
|
|
1726
2620
|
}, "strip", z.ZodTypeAny, {
|
|
1727
2621
|
headers?: {
|
|
1728
|
-
key: string;
|
|
1729
2622
|
value: string;
|
|
2623
|
+
key: string;
|
|
1730
2624
|
omitIfEmpty?: boolean | undefined;
|
|
1731
2625
|
}[] | undefined;
|
|
1732
2626
|
parameters?: {
|
|
1733
|
-
key: string;
|
|
1734
2627
|
value: string;
|
|
2628
|
+
key: string;
|
|
1735
2629
|
omitIfEmpty?: boolean | undefined;
|
|
1736
2630
|
}[] | undefined;
|
|
1737
2631
|
variables?: Record<string, {
|
|
@@ -1744,13 +2638,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1744
2638
|
}> | undefined;
|
|
1745
2639
|
}, {
|
|
1746
2640
|
headers?: {
|
|
1747
|
-
key: string;
|
|
1748
2641
|
value: string;
|
|
2642
|
+
key: string;
|
|
1749
2643
|
omitIfEmpty?: boolean | undefined;
|
|
1750
2644
|
}[] | undefined;
|
|
1751
2645
|
parameters?: {
|
|
1752
|
-
key: string;
|
|
1753
2646
|
value: string;
|
|
2647
|
+
key: string;
|
|
1754
2648
|
omitIfEmpty?: boolean | undefined;
|
|
1755
2649
|
}[] | undefined;
|
|
1756
2650
|
variables?: Record<string, {
|
|
@@ -1771,13 +2665,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1771
2665
|
}, "strip", z.ZodTypeAny, {
|
|
1772
2666
|
unpublished?: ({
|
|
1773
2667
|
headers?: {
|
|
1774
|
-
key: string;
|
|
1775
2668
|
value: string;
|
|
2669
|
+
key: string;
|
|
1776
2670
|
omitIfEmpty?: boolean | undefined;
|
|
1777
2671
|
}[] | undefined;
|
|
1778
2672
|
parameters?: {
|
|
1779
|
-
key: string;
|
|
1780
2673
|
value: string;
|
|
2674
|
+
key: string;
|
|
1781
2675
|
omitIfEmpty?: boolean | undefined;
|
|
1782
2676
|
}[] | undefined;
|
|
1783
2677
|
variables?: Record<string, {
|
|
@@ -1794,13 +2688,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1794
2688
|
}, {
|
|
1795
2689
|
unpublished?: ({
|
|
1796
2690
|
headers?: {
|
|
1797
|
-
key: string;
|
|
1798
2691
|
value: string;
|
|
2692
|
+
key: string;
|
|
1799
2693
|
omitIfEmpty?: boolean | undefined;
|
|
1800
2694
|
}[] | undefined;
|
|
1801
2695
|
parameters?: {
|
|
1802
|
-
key: string;
|
|
1803
2696
|
value: string;
|
|
2697
|
+
key: string;
|
|
1804
2698
|
omitIfEmpty?: boolean | undefined;
|
|
1805
2699
|
}[] | undefined;
|
|
1806
2700
|
variables?: Record<string, {
|
|
@@ -1816,19 +2710,19 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1816
2710
|
}) | undefined;
|
|
1817
2711
|
}>>;
|
|
1818
2712
|
enableUnpublishedMode: z.ZodOptional<z.ZodBoolean>;
|
|
1819
|
-
}, "
|
|
2713
|
+
}, "id" | "displayName" | "variables" | "allowedOnComponents" | "badgeIconUrl" | "purgeKey" | "edgehancer">, "strip", z.ZodTypeAny, {
|
|
1820
2714
|
url: string;
|
|
1821
2715
|
connectorType: string;
|
|
1822
2716
|
method: "GET" | "POST" | "HEAD";
|
|
1823
2717
|
custom?: Record<string, unknown> | undefined;
|
|
1824
2718
|
headers?: {
|
|
1825
|
-
key: string;
|
|
1826
2719
|
value: string;
|
|
2720
|
+
key: string;
|
|
1827
2721
|
omitIfEmpty?: boolean | undefined;
|
|
1828
2722
|
}[] | undefined;
|
|
1829
2723
|
parameters?: {
|
|
1830
|
-
key: string;
|
|
1831
2724
|
value: string;
|
|
2725
|
+
key: string;
|
|
1832
2726
|
omitIfEmpty?: boolean | undefined;
|
|
1833
2727
|
}[] | undefined;
|
|
1834
2728
|
archetype?: string | undefined;
|
|
@@ -1840,13 +2734,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1840
2734
|
variants?: {
|
|
1841
2735
|
unpublished?: ({
|
|
1842
2736
|
headers?: {
|
|
1843
|
-
key: string;
|
|
1844
2737
|
value: string;
|
|
2738
|
+
key: string;
|
|
1845
2739
|
omitIfEmpty?: boolean | undefined;
|
|
1846
2740
|
}[] | undefined;
|
|
1847
2741
|
parameters?: {
|
|
1848
|
-
key: string;
|
|
1849
2742
|
value: string;
|
|
2743
|
+
key: string;
|
|
1850
2744
|
omitIfEmpty?: boolean | undefined;
|
|
1851
2745
|
}[] | undefined;
|
|
1852
2746
|
variables?: Record<string, {
|
|
@@ -1868,13 +2762,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1868
2762
|
method: "GET" | "POST" | "HEAD";
|
|
1869
2763
|
custom?: Record<string, unknown> | undefined;
|
|
1870
2764
|
headers?: {
|
|
1871
|
-
key: string;
|
|
1872
2765
|
value: string;
|
|
2766
|
+
key: string;
|
|
1873
2767
|
omitIfEmpty?: boolean | undefined;
|
|
1874
2768
|
}[] | undefined;
|
|
1875
2769
|
parameters?: {
|
|
1876
|
-
key: string;
|
|
1877
2770
|
value: string;
|
|
2771
|
+
key: string;
|
|
1878
2772
|
omitIfEmpty?: boolean | undefined;
|
|
1879
2773
|
}[] | undefined;
|
|
1880
2774
|
archetype?: string | undefined;
|
|
@@ -1886,13 +2780,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1886
2780
|
variants?: {
|
|
1887
2781
|
unpublished?: ({
|
|
1888
2782
|
headers?: {
|
|
1889
|
-
key: string;
|
|
1890
2783
|
value: string;
|
|
2784
|
+
key: string;
|
|
1891
2785
|
omitIfEmpty?: boolean | undefined;
|
|
1892
2786
|
}[] | undefined;
|
|
1893
2787
|
parameters?: {
|
|
1894
|
-
key: string;
|
|
1895
2788
|
value: string;
|
|
2789
|
+
key: string;
|
|
1896
2790
|
omitIfEmpty?: boolean | undefined;
|
|
1897
2791
|
}[] | undefined;
|
|
1898
2792
|
variables?: Record<string, {
|
|
@@ -1916,13 +2810,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1916
2810
|
method: "GET" | "POST" | "HEAD";
|
|
1917
2811
|
custom?: Record<string, unknown> | undefined;
|
|
1918
2812
|
headers?: {
|
|
1919
|
-
key: string;
|
|
1920
2813
|
value: string;
|
|
2814
|
+
key: string;
|
|
1921
2815
|
omitIfEmpty?: boolean | undefined;
|
|
1922
2816
|
}[] | undefined;
|
|
1923
2817
|
parameters?: {
|
|
1924
|
-
key: string;
|
|
1925
2818
|
value: string;
|
|
2819
|
+
key: string;
|
|
1926
2820
|
omitIfEmpty?: boolean | undefined;
|
|
1927
2821
|
}[] | undefined;
|
|
1928
2822
|
archetype?: string | undefined;
|
|
@@ -1934,13 +2828,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1934
2828
|
variants?: {
|
|
1935
2829
|
unpublished?: ({
|
|
1936
2830
|
headers?: {
|
|
1937
|
-
key: string;
|
|
1938
2831
|
value: string;
|
|
2832
|
+
key: string;
|
|
1939
2833
|
omitIfEmpty?: boolean | undefined;
|
|
1940
2834
|
}[] | undefined;
|
|
1941
2835
|
parameters?: {
|
|
1942
|
-
key: string;
|
|
1943
2836
|
value: string;
|
|
2837
|
+
key: string;
|
|
1944
2838
|
omitIfEmpty?: boolean | undefined;
|
|
1945
2839
|
}[] | undefined;
|
|
1946
2840
|
variables?: Record<string, {
|
|
@@ -1982,13 +2876,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
1982
2876
|
method: "GET" | "POST" | "HEAD";
|
|
1983
2877
|
custom?: Record<string, unknown> | undefined;
|
|
1984
2878
|
headers?: {
|
|
1985
|
-
key: string;
|
|
1986
2879
|
value: string;
|
|
2880
|
+
key: string;
|
|
1987
2881
|
omitIfEmpty?: boolean | undefined;
|
|
1988
2882
|
}[] | undefined;
|
|
1989
2883
|
parameters?: {
|
|
1990
|
-
key: string;
|
|
1991
2884
|
value: string;
|
|
2885
|
+
key: string;
|
|
1992
2886
|
omitIfEmpty?: boolean | undefined;
|
|
1993
2887
|
}[] | undefined;
|
|
1994
2888
|
archetype?: string | undefined;
|
|
@@ -2000,13 +2894,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
2000
2894
|
variants?: {
|
|
2001
2895
|
unpublished?: ({
|
|
2002
2896
|
headers?: {
|
|
2003
|
-
key: string;
|
|
2004
2897
|
value: string;
|
|
2898
|
+
key: string;
|
|
2005
2899
|
omitIfEmpty?: boolean | undefined;
|
|
2006
2900
|
}[] | undefined;
|
|
2007
2901
|
parameters?: {
|
|
2008
|
-
key: string;
|
|
2009
2902
|
value: string;
|
|
2903
|
+
key: string;
|
|
2010
2904
|
omitIfEmpty?: boolean | undefined;
|
|
2011
2905
|
}[] | undefined;
|
|
2012
2906
|
variables?: Record<string, {
|
|
@@ -2050,13 +2944,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
2050
2944
|
method: "GET" | "POST" | "HEAD";
|
|
2051
2945
|
custom?: Record<string, unknown> | undefined;
|
|
2052
2946
|
headers?: {
|
|
2053
|
-
key: string;
|
|
2054
2947
|
value: string;
|
|
2948
|
+
key: string;
|
|
2055
2949
|
omitIfEmpty?: boolean | undefined;
|
|
2056
2950
|
}[] | undefined;
|
|
2057
2951
|
parameters?: {
|
|
2058
|
-
key: string;
|
|
2059
2952
|
value: string;
|
|
2953
|
+
key: string;
|
|
2060
2954
|
omitIfEmpty?: boolean | undefined;
|
|
2061
2955
|
}[] | undefined;
|
|
2062
2956
|
archetype?: string | undefined;
|
|
@@ -2068,13 +2962,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
2068
2962
|
variants?: {
|
|
2069
2963
|
unpublished?: ({
|
|
2070
2964
|
headers?: {
|
|
2071
|
-
key: string;
|
|
2072
2965
|
value: string;
|
|
2966
|
+
key: string;
|
|
2073
2967
|
omitIfEmpty?: boolean | undefined;
|
|
2074
2968
|
}[] | undefined;
|
|
2075
2969
|
parameters?: {
|
|
2076
|
-
key: string;
|
|
2077
2970
|
value: string;
|
|
2971
|
+
key: string;
|
|
2078
2972
|
omitIfEmpty?: boolean | undefined;
|
|
2079
2973
|
}[] | undefined;
|
|
2080
2974
|
variables?: Record<string, {
|
|
@@ -2118,13 +3012,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
2118
3012
|
method: "GET" | "POST" | "HEAD";
|
|
2119
3013
|
custom?: Record<string, unknown> | undefined;
|
|
2120
3014
|
headers?: {
|
|
2121
|
-
key: string;
|
|
2122
3015
|
value: string;
|
|
3016
|
+
key: string;
|
|
2123
3017
|
omitIfEmpty?: boolean | undefined;
|
|
2124
3018
|
}[] | undefined;
|
|
2125
3019
|
parameters?: {
|
|
2126
|
-
key: string;
|
|
2127
3020
|
value: string;
|
|
3021
|
+
key: string;
|
|
2128
3022
|
omitIfEmpty?: boolean | undefined;
|
|
2129
3023
|
}[] | undefined;
|
|
2130
3024
|
archetype?: string | undefined;
|
|
@@ -2136,13 +3030,13 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
2136
3030
|
variants?: {
|
|
2137
3031
|
unpublished?: ({
|
|
2138
3032
|
headers?: {
|
|
2139
|
-
key: string;
|
|
2140
3033
|
value: string;
|
|
3034
|
+
key: string;
|
|
2141
3035
|
omitIfEmpty?: boolean | undefined;
|
|
2142
3036
|
}[] | undefined;
|
|
2143
3037
|
parameters?: {
|
|
2144
|
-
key: string;
|
|
2145
3038
|
value: string;
|
|
3039
|
+
key: string;
|
|
2146
3040
|
omitIfEmpty?: boolean | undefined;
|
|
2147
3041
|
}[] | undefined;
|
|
2148
3042
|
variables?: Record<string, {
|
|
@@ -2192,4 +3086,4 @@ declare function getDataResourceQueryString({ parameters, url }: EdgehancerMerge
|
|
|
2192
3086
|
/** Gets the HTTP headers for a data resource */
|
|
2193
3087
|
declare function getDataResourceHeaders({ headers }: EdgehancerMergedDataType): Headers;
|
|
2194
3088
|
|
|
2195
|
-
export { COLLECTION_DEFAULT_LIMIT, COLLECTION_DEFAULT_OFFSET, COLLECTION_MAX_LIMIT, type ConvertBatchResultsToEdgehancerResultOptions, type CustomEdgehancerDefinition, type DataResource, type DataResourceFetchContext, type EdgehancerDataIssue, type EdgehancerMergedDataType, type MergedDataType, type PreRequestEdgehancerContext, type PreRequestEdgehancerDataResourceContext, type PreRequestEdgehancerDataResourceResult, type PreRequestEdgehancerResult, type PreRequestHookFn, type RequestEdgehancerContext, type RequestEdgehancerDataResourceContext, type RequestEdgehancerDataResourceResolutionResult, type RequestEdgehancerResult, type RequestHookFn, type ResolveBatchIdsResult, convertBatchResultsToEdgehancerResult, dataResourceSchema, edgehancerMergedDataTypeSchema, getDataResourceAsRequest, getDataResourceHeaders, getDataResourceQueryString, getDataResourceUrl, mergedDataTypeSchema, preRequestEdgehancerDataResourceResultSchema, preRequestEdgehancerResultSchema, requestEdgehancerDataResourceResolutionResultSchema, requestEdgehancerResultSchema, resolveBatchFetchIds, resolvingIssueSchema };
|
|
3089
|
+
export { type AfterAIDataResourceEditContext, type AfterAIDataResourceEditHookFn, type AfterAIDataResourceEditResult, type AfterAIEditContext, type AfterAIEditHookFn, type AfterAIEditResult, COLLECTION_DEFAULT_LIMIT, COLLECTION_DEFAULT_OFFSET, COLLECTION_MAX_LIMIT, type ConvertBatchResultsToEdgehancerResultOptions, type CreateAIDataResourceEditContext, type CreateAIDataResourceEditHookFn, type CreateAIDataResourceEditResult, type CreateAIEditContext, type CreateAIEditHookFn, type CreateAIEditResult, type CustomEdgehancerDefinition, type DataResource, type DataResourceFetchContext, type EdgehancerDataIssue, type EdgehancerMergedDataType, type MergedDataType, type PreRequestEdgehancerContext, type PreRequestEdgehancerDataResourceContext, type PreRequestEdgehancerDataResourceResult, type PreRequestEdgehancerResult, type PreRequestHookFn, type RequestEdgehancerContext, type RequestEdgehancerDataResourceContext, type RequestEdgehancerDataResourceResolutionResult, type RequestEdgehancerResult, type RequestHookFn, type ResolveBatchIdsResult, afterAIDataResourceEditContextSchema, afterAIDataResourceEditResultSchema, afterAIEditContextSchema, afterAIEditResultSchema, convertBatchResultsToEdgehancerResult, createAIDataResourceEditContextSchema, createAIDataResourceEditResultSchema, createAIEditContextSchema, createAIEditResultSchema, dataResourceSchema, edgehancerMergedDataTypeSchema, getDataResourceAsRequest, getDataResourceHeaders, getDataResourceQueryString, getDataResourceUrl, mergedDataTypeSchema, preRequestEdgehancerDataResourceResultSchema, preRequestEdgehancerResultSchema, requestEdgehancerDataResourceResolutionResultSchema, requestEdgehancerResultSchema, resolveBatchFetchIds, resolvingIssueSchema };
|