@uniformdev/mesh-edgehancer-sdk 19.185.1-alpha.8 → 19.186.2-alpha.14
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 +996 -53
- package/dist/index.d.ts +996 -53
- package/dist/index.esm.js +13 -1
- package/dist/index.js +13 -1
- package/dist/index.mjs +13 -1
- package/package.json +3 -3
package/dist/index.d.ts
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import * as zod from 'zod';
|
|
2
2
|
import { z } from 'zod';
|
|
3
|
-
import { DataType, DataSource } from '@uniformdev/canvas';
|
|
3
|
+
import { DataType, DataSource, DataSourceVariantsKeys, DataSourceVariantData } from '@uniformdev/canvas';
|
|
4
4
|
|
|
5
5
|
/**
|
|
6
6
|
* The context we are fetching the data resource in:
|
|
@@ -97,15 +97,156 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
97
97
|
request?: string | undefined;
|
|
98
98
|
}>>;
|
|
99
99
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
100
|
+
variants: z.ZodOptional<z.ZodObject<{
|
|
101
|
+
unpublished: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
|
|
102
|
+
headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
103
|
+
key: z.ZodString;
|
|
104
|
+
value: z.ZodString;
|
|
105
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
106
|
+
}, "strip", z.ZodTypeAny, {
|
|
107
|
+
key: string;
|
|
108
|
+
value: string;
|
|
109
|
+
omitIfEmpty?: boolean | undefined;
|
|
110
|
+
}, {
|
|
111
|
+
key: string;
|
|
112
|
+
value: string;
|
|
113
|
+
omitIfEmpty?: boolean | undefined;
|
|
114
|
+
}>, "many">>;
|
|
115
|
+
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
116
|
+
key: z.ZodString;
|
|
117
|
+
value: z.ZodString;
|
|
118
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
119
|
+
}, "strip", z.ZodTypeAny, {
|
|
120
|
+
key: string;
|
|
121
|
+
value: string;
|
|
122
|
+
omitIfEmpty?: boolean | undefined;
|
|
123
|
+
}, {
|
|
124
|
+
key: string;
|
|
125
|
+
value: string;
|
|
126
|
+
omitIfEmpty?: boolean | undefined;
|
|
127
|
+
}>, "many">>;
|
|
128
|
+
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
129
|
+
displayName: z.ZodOptional<z.ZodString>;
|
|
130
|
+
type: z.ZodOptional<z.ZodString>;
|
|
131
|
+
default: z.ZodString;
|
|
132
|
+
helpText: z.ZodOptional<z.ZodString>;
|
|
133
|
+
order: z.ZodOptional<z.ZodNumber>;
|
|
134
|
+
source: z.ZodOptional<z.ZodString>;
|
|
135
|
+
}, "strip", z.ZodTypeAny, {
|
|
136
|
+
default: string;
|
|
137
|
+
type?: string | undefined;
|
|
138
|
+
displayName?: string | undefined;
|
|
139
|
+
helpText?: string | undefined;
|
|
140
|
+
order?: number | undefined;
|
|
141
|
+
source?: string | undefined;
|
|
142
|
+
}, {
|
|
143
|
+
default: string;
|
|
144
|
+
type?: string | undefined;
|
|
145
|
+
displayName?: string | undefined;
|
|
146
|
+
helpText?: string | undefined;
|
|
147
|
+
order?: number | undefined;
|
|
148
|
+
source?: string | undefined;
|
|
149
|
+
}>>>;
|
|
150
|
+
}, "strip", z.ZodTypeAny, {
|
|
151
|
+
headers?: {
|
|
152
|
+
key: string;
|
|
153
|
+
value: string;
|
|
154
|
+
omitIfEmpty?: boolean | undefined;
|
|
155
|
+
}[] | undefined;
|
|
156
|
+
parameters?: {
|
|
157
|
+
key: string;
|
|
158
|
+
value: string;
|
|
159
|
+
omitIfEmpty?: boolean | undefined;
|
|
160
|
+
}[] | undefined;
|
|
161
|
+
variables?: Record<string, {
|
|
162
|
+
default: string;
|
|
163
|
+
type?: string | undefined;
|
|
164
|
+
displayName?: string | undefined;
|
|
165
|
+
helpText?: string | undefined;
|
|
166
|
+
order?: number | undefined;
|
|
167
|
+
source?: string | undefined;
|
|
168
|
+
}> | undefined;
|
|
169
|
+
}, {
|
|
170
|
+
headers?: {
|
|
171
|
+
key: string;
|
|
172
|
+
value: string;
|
|
173
|
+
omitIfEmpty?: boolean | undefined;
|
|
174
|
+
}[] | undefined;
|
|
175
|
+
parameters?: {
|
|
176
|
+
key: string;
|
|
177
|
+
value: string;
|
|
178
|
+
omitIfEmpty?: boolean | undefined;
|
|
179
|
+
}[] | undefined;
|
|
180
|
+
variables?: Record<string, {
|
|
181
|
+
default: string;
|
|
182
|
+
type?: string | undefined;
|
|
183
|
+
displayName?: string | undefined;
|
|
184
|
+
helpText?: string | undefined;
|
|
185
|
+
order?: number | undefined;
|
|
186
|
+
source?: string | undefined;
|
|
187
|
+
}> | undefined;
|
|
188
|
+
}>, z.ZodObject<{
|
|
189
|
+
url: z.ZodString;
|
|
190
|
+
}, "strip", z.ZodTypeAny, {
|
|
191
|
+
url: string;
|
|
192
|
+
}, {
|
|
193
|
+
url: string;
|
|
194
|
+
}>>>;
|
|
195
|
+
}, "strip", z.ZodTypeAny, {
|
|
196
|
+
unpublished?: ({
|
|
197
|
+
headers?: {
|
|
198
|
+
key: string;
|
|
199
|
+
value: string;
|
|
200
|
+
omitIfEmpty?: boolean | undefined;
|
|
201
|
+
}[] | undefined;
|
|
202
|
+
parameters?: {
|
|
203
|
+
key: string;
|
|
204
|
+
value: string;
|
|
205
|
+
omitIfEmpty?: boolean | undefined;
|
|
206
|
+
}[] | undefined;
|
|
207
|
+
variables?: Record<string, {
|
|
208
|
+
default: string;
|
|
209
|
+
type?: string | undefined;
|
|
210
|
+
displayName?: string | undefined;
|
|
211
|
+
helpText?: string | undefined;
|
|
212
|
+
order?: number | undefined;
|
|
213
|
+
source?: string | undefined;
|
|
214
|
+
}> | undefined;
|
|
215
|
+
} & {
|
|
216
|
+
url: string;
|
|
217
|
+
}) | undefined;
|
|
218
|
+
}, {
|
|
219
|
+
unpublished?: ({
|
|
220
|
+
headers?: {
|
|
221
|
+
key: string;
|
|
222
|
+
value: string;
|
|
223
|
+
omitIfEmpty?: boolean | undefined;
|
|
224
|
+
}[] | undefined;
|
|
225
|
+
parameters?: {
|
|
226
|
+
key: string;
|
|
227
|
+
value: string;
|
|
228
|
+
omitIfEmpty?: boolean | undefined;
|
|
229
|
+
}[] | undefined;
|
|
230
|
+
variables?: Record<string, {
|
|
231
|
+
default: string;
|
|
232
|
+
type?: string | undefined;
|
|
233
|
+
displayName?: string | undefined;
|
|
234
|
+
helpText?: string | undefined;
|
|
235
|
+
order?: number | undefined;
|
|
236
|
+
source?: string | undefined;
|
|
237
|
+
}> | undefined;
|
|
238
|
+
} & {
|
|
239
|
+
url: string;
|
|
240
|
+
}) | undefined;
|
|
241
|
+
}>>;
|
|
242
|
+
dataSourceVariant: z.ZodOptional<z.ZodEnum<["unpublished"]>>;
|
|
100
243
|
}, "strip", z.ZodTypeAny, {
|
|
101
244
|
displayName: string;
|
|
245
|
+
url: string;
|
|
102
246
|
id: string;
|
|
103
247
|
connectorType: string;
|
|
104
|
-
url: string;
|
|
105
248
|
method: "GET" | "POST" | "HEAD";
|
|
106
|
-
|
|
107
|
-
allowedOnComponents?: string[] | undefined;
|
|
108
|
-
badgeIconUrl?: string | undefined;
|
|
249
|
+
custom?: Record<string, unknown> | undefined;
|
|
109
250
|
headers?: {
|
|
110
251
|
key: string;
|
|
111
252
|
value: string;
|
|
@@ -116,8 +257,6 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
116
257
|
value: string;
|
|
117
258
|
omitIfEmpty?: boolean | undefined;
|
|
118
259
|
}[] | undefined;
|
|
119
|
-
body?: string | undefined;
|
|
120
|
-
custom?: Record<string, unknown> | undefined;
|
|
121
260
|
variables?: Record<string, {
|
|
122
261
|
default: string;
|
|
123
262
|
type?: string | undefined;
|
|
@@ -126,6 +265,10 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
126
265
|
order?: number | undefined;
|
|
127
266
|
source?: string | undefined;
|
|
128
267
|
}> | undefined;
|
|
268
|
+
archetype?: string | undefined;
|
|
269
|
+
allowedOnComponents?: string[] | undefined;
|
|
270
|
+
badgeIconUrl?: string | undefined;
|
|
271
|
+
body?: string | undefined;
|
|
129
272
|
customPublic?: Record<string, unknown> | undefined;
|
|
130
273
|
ttl?: number | undefined;
|
|
131
274
|
purgeKey?: string | undefined;
|
|
@@ -135,15 +278,38 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
135
278
|
request?: string | undefined;
|
|
136
279
|
} | undefined;
|
|
137
280
|
uiBadgeText?: string | undefined;
|
|
281
|
+
variants?: {
|
|
282
|
+
unpublished?: ({
|
|
283
|
+
headers?: {
|
|
284
|
+
key: string;
|
|
285
|
+
value: string;
|
|
286
|
+
omitIfEmpty?: boolean | undefined;
|
|
287
|
+
}[] | undefined;
|
|
288
|
+
parameters?: {
|
|
289
|
+
key: string;
|
|
290
|
+
value: string;
|
|
291
|
+
omitIfEmpty?: boolean | undefined;
|
|
292
|
+
}[] | undefined;
|
|
293
|
+
variables?: Record<string, {
|
|
294
|
+
default: string;
|
|
295
|
+
type?: string | undefined;
|
|
296
|
+
displayName?: string | undefined;
|
|
297
|
+
helpText?: string | undefined;
|
|
298
|
+
order?: number | undefined;
|
|
299
|
+
source?: string | undefined;
|
|
300
|
+
}> | undefined;
|
|
301
|
+
} & {
|
|
302
|
+
url: string;
|
|
303
|
+
}) | undefined;
|
|
304
|
+
} | undefined;
|
|
305
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
138
306
|
}, {
|
|
139
307
|
displayName: string;
|
|
308
|
+
url: string;
|
|
140
309
|
id: string;
|
|
141
310
|
connectorType: string;
|
|
142
|
-
url: string;
|
|
143
311
|
method: "GET" | "POST" | "HEAD";
|
|
144
|
-
|
|
145
|
-
allowedOnComponents?: string[] | undefined;
|
|
146
|
-
badgeIconUrl?: string | undefined;
|
|
312
|
+
custom?: Record<string, unknown> | undefined;
|
|
147
313
|
headers?: {
|
|
148
314
|
key: string;
|
|
149
315
|
value: string;
|
|
@@ -154,8 +320,6 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
154
320
|
value: string;
|
|
155
321
|
omitIfEmpty?: boolean | undefined;
|
|
156
322
|
}[] | undefined;
|
|
157
|
-
body?: string | undefined;
|
|
158
|
-
custom?: Record<string, unknown> | undefined;
|
|
159
323
|
variables?: Record<string, {
|
|
160
324
|
default: string;
|
|
161
325
|
type?: string | undefined;
|
|
@@ -164,6 +328,10 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
164
328
|
order?: number | undefined;
|
|
165
329
|
source?: string | undefined;
|
|
166
330
|
}> | undefined;
|
|
331
|
+
archetype?: string | undefined;
|
|
332
|
+
allowedOnComponents?: string[] | undefined;
|
|
333
|
+
badgeIconUrl?: string | undefined;
|
|
334
|
+
body?: string | undefined;
|
|
167
335
|
customPublic?: Record<string, unknown> | undefined;
|
|
168
336
|
ttl?: number | undefined;
|
|
169
337
|
purgeKey?: string | undefined;
|
|
@@ -173,13 +341,48 @@ declare const mergedDataTypeSchema: z.ZodObject<{
|
|
|
173
341
|
request?: string | undefined;
|
|
174
342
|
} | undefined;
|
|
175
343
|
uiBadgeText?: string | undefined;
|
|
344
|
+
variants?: {
|
|
345
|
+
unpublished?: ({
|
|
346
|
+
headers?: {
|
|
347
|
+
key: string;
|
|
348
|
+
value: string;
|
|
349
|
+
omitIfEmpty?: boolean | undefined;
|
|
350
|
+
}[] | undefined;
|
|
351
|
+
parameters?: {
|
|
352
|
+
key: string;
|
|
353
|
+
value: string;
|
|
354
|
+
omitIfEmpty?: boolean | undefined;
|
|
355
|
+
}[] | undefined;
|
|
356
|
+
variables?: Record<string, {
|
|
357
|
+
default: string;
|
|
358
|
+
type?: string | undefined;
|
|
359
|
+
displayName?: string | undefined;
|
|
360
|
+
helpText?: string | undefined;
|
|
361
|
+
order?: number | undefined;
|
|
362
|
+
source?: string | undefined;
|
|
363
|
+
}> | undefined;
|
|
364
|
+
} & {
|
|
365
|
+
url: string;
|
|
366
|
+
}) | undefined;
|
|
367
|
+
} | undefined;
|
|
368
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
176
369
|
}>;
|
|
177
370
|
/** Declaration of custom edgehancer hooks on a merged data type */
|
|
178
371
|
type CustomEdgehancerDefinition = z.infer<typeof customEdgehancerDefinitionSchema>;
|
|
179
372
|
/**
|
|
180
373
|
* The result of merging a data source with a data type into a single request object
|
|
181
374
|
*/
|
|
182
|
-
type MergedDataType = Omit<DataType, '
|
|
375
|
+
type MergedDataType = Omit<DataType, 'dataSourceId' | 'path'> & Pick<DataSource, 'connectorType' | 'localeMapping' | 'customPublic'> & {
|
|
376
|
+
/**
|
|
377
|
+
* Data Source variants with "url" with the merged DS base URL and DT relative URL,
|
|
378
|
+
* same way we have the "url" in the MergedDataType. We need it merged for mergeDataResourcesWithDataTypes() to switch between variants
|
|
379
|
+
* But as DS baseUrl contains origin and base path, it is not clear which part of merged "url" we need to change while switching between DS variants.
|
|
380
|
+
*
|
|
381
|
+
* Removing "baseUrl" from the variant to keep consistency with MergedDataType
|
|
382
|
+
*/
|
|
383
|
+
variants?: Partial<Record<DataSourceVariantsKeys, Omit<NonNullable<DataSourceVariantData>, 'baseUrl'> & {
|
|
384
|
+
url: string;
|
|
385
|
+
}>>;
|
|
183
386
|
/** Merged base URL from the data source with the relative URL from the data type */
|
|
184
387
|
url: string;
|
|
185
388
|
/**
|
|
@@ -193,6 +396,7 @@ type MergedDataType = Omit<DataType, 'path' | 'dataSourceId'> & Pick<DataSource,
|
|
|
193
396
|
* Max length 12
|
|
194
397
|
*/
|
|
195
398
|
uiBadgeText?: string;
|
|
399
|
+
dataSourceVariant?: DataSourceVariantsKeys;
|
|
196
400
|
};
|
|
197
401
|
declare const dataResourceSchema: 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]>;
|
|
198
402
|
/** A data resource of JSON data retrieved from a data type/data source */
|
|
@@ -211,6 +415,12 @@ type RequestEdgehancerContext = {
|
|
|
211
415
|
* that the handler is registered for.
|
|
212
416
|
*/
|
|
213
417
|
dataResources: readonly RequestEdgehancerDataResourceContext[];
|
|
418
|
+
/**
|
|
419
|
+
* Which Data Source variant to use for the request. For example in case of "unpublished" variant Request hook can add aditional data modification, add unpublished mode related warnings, etc.
|
|
420
|
+
*
|
|
421
|
+
* Make sure that you implement PreRequest hook as well to handle request modification before edgehancer will make a cache lookup.
|
|
422
|
+
*/
|
|
423
|
+
dataSourceVariant?: DataSourceVariantsKeys;
|
|
214
424
|
};
|
|
215
425
|
declare const requestEdgehancerDataResourceResolutionResultSchema: z.ZodObject<{
|
|
216
426
|
errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -382,11 +592,154 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
382
592
|
request?: string | undefined;
|
|
383
593
|
}>>;
|
|
384
594
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
385
|
-
|
|
386
|
-
|
|
595
|
+
variants: z.ZodOptional<z.ZodObject<{
|
|
596
|
+
unpublished: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
|
|
597
|
+
headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
598
|
+
key: z.ZodString;
|
|
599
|
+
value: z.ZodString;
|
|
600
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
601
|
+
}, "strip", z.ZodTypeAny, {
|
|
602
|
+
key: string;
|
|
603
|
+
value: string;
|
|
604
|
+
omitIfEmpty?: boolean | undefined;
|
|
605
|
+
}, {
|
|
606
|
+
key: string;
|
|
607
|
+
value: string;
|
|
608
|
+
omitIfEmpty?: boolean | undefined;
|
|
609
|
+
}>, "many">>;
|
|
610
|
+
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
611
|
+
key: z.ZodString;
|
|
612
|
+
value: z.ZodString;
|
|
613
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
614
|
+
}, "strip", z.ZodTypeAny, {
|
|
615
|
+
key: string;
|
|
616
|
+
value: string;
|
|
617
|
+
omitIfEmpty?: boolean | undefined;
|
|
618
|
+
}, {
|
|
619
|
+
key: string;
|
|
620
|
+
value: string;
|
|
621
|
+
omitIfEmpty?: boolean | undefined;
|
|
622
|
+
}>, "many">>;
|
|
623
|
+
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
624
|
+
displayName: z.ZodOptional<z.ZodString>;
|
|
625
|
+
type: z.ZodOptional<z.ZodString>;
|
|
626
|
+
default: z.ZodString;
|
|
627
|
+
helpText: z.ZodOptional<z.ZodString>;
|
|
628
|
+
order: z.ZodOptional<z.ZodNumber>;
|
|
629
|
+
source: z.ZodOptional<z.ZodString>;
|
|
630
|
+
}, "strip", z.ZodTypeAny, {
|
|
631
|
+
default: string;
|
|
632
|
+
type?: string | undefined;
|
|
633
|
+
displayName?: string | undefined;
|
|
634
|
+
helpText?: string | undefined;
|
|
635
|
+
order?: number | undefined;
|
|
636
|
+
source?: string | undefined;
|
|
637
|
+
}, {
|
|
638
|
+
default: string;
|
|
639
|
+
type?: string | undefined;
|
|
640
|
+
displayName?: string | undefined;
|
|
641
|
+
helpText?: string | undefined;
|
|
642
|
+
order?: number | undefined;
|
|
643
|
+
source?: string | undefined;
|
|
644
|
+
}>>>;
|
|
645
|
+
}, "strip", z.ZodTypeAny, {
|
|
646
|
+
headers?: {
|
|
647
|
+
key: string;
|
|
648
|
+
value: string;
|
|
649
|
+
omitIfEmpty?: boolean | undefined;
|
|
650
|
+
}[] | undefined;
|
|
651
|
+
parameters?: {
|
|
652
|
+
key: string;
|
|
653
|
+
value: string;
|
|
654
|
+
omitIfEmpty?: boolean | undefined;
|
|
655
|
+
}[] | undefined;
|
|
656
|
+
variables?: Record<string, {
|
|
657
|
+
default: string;
|
|
658
|
+
type?: string | undefined;
|
|
659
|
+
displayName?: string | undefined;
|
|
660
|
+
helpText?: string | undefined;
|
|
661
|
+
order?: number | undefined;
|
|
662
|
+
source?: string | undefined;
|
|
663
|
+
}> | undefined;
|
|
664
|
+
}, {
|
|
665
|
+
headers?: {
|
|
666
|
+
key: string;
|
|
667
|
+
value: string;
|
|
668
|
+
omitIfEmpty?: boolean | undefined;
|
|
669
|
+
}[] | undefined;
|
|
670
|
+
parameters?: {
|
|
671
|
+
key: string;
|
|
672
|
+
value: string;
|
|
673
|
+
omitIfEmpty?: boolean | undefined;
|
|
674
|
+
}[] | undefined;
|
|
675
|
+
variables?: Record<string, {
|
|
676
|
+
default: string;
|
|
677
|
+
type?: string | undefined;
|
|
678
|
+
displayName?: string | undefined;
|
|
679
|
+
helpText?: string | undefined;
|
|
680
|
+
order?: number | undefined;
|
|
681
|
+
source?: string | undefined;
|
|
682
|
+
}> | undefined;
|
|
683
|
+
}>, z.ZodObject<{
|
|
684
|
+
url: z.ZodString;
|
|
685
|
+
}, "strip", z.ZodTypeAny, {
|
|
686
|
+
url: string;
|
|
687
|
+
}, {
|
|
688
|
+
url: string;
|
|
689
|
+
}>>>;
|
|
690
|
+
}, "strip", z.ZodTypeAny, {
|
|
691
|
+
unpublished?: ({
|
|
692
|
+
headers?: {
|
|
693
|
+
key: string;
|
|
694
|
+
value: string;
|
|
695
|
+
omitIfEmpty?: boolean | undefined;
|
|
696
|
+
}[] | undefined;
|
|
697
|
+
parameters?: {
|
|
698
|
+
key: string;
|
|
699
|
+
value: string;
|
|
700
|
+
omitIfEmpty?: boolean | undefined;
|
|
701
|
+
}[] | undefined;
|
|
702
|
+
variables?: Record<string, {
|
|
703
|
+
default: string;
|
|
704
|
+
type?: string | undefined;
|
|
705
|
+
displayName?: string | undefined;
|
|
706
|
+
helpText?: string | undefined;
|
|
707
|
+
order?: number | undefined;
|
|
708
|
+
source?: string | undefined;
|
|
709
|
+
}> | undefined;
|
|
710
|
+
} & {
|
|
711
|
+
url: string;
|
|
712
|
+
}) | undefined;
|
|
713
|
+
}, {
|
|
714
|
+
unpublished?: ({
|
|
715
|
+
headers?: {
|
|
716
|
+
key: string;
|
|
717
|
+
value: string;
|
|
718
|
+
omitIfEmpty?: boolean | undefined;
|
|
719
|
+
}[] | undefined;
|
|
720
|
+
parameters?: {
|
|
721
|
+
key: string;
|
|
722
|
+
value: string;
|
|
723
|
+
omitIfEmpty?: boolean | undefined;
|
|
724
|
+
}[] | undefined;
|
|
725
|
+
variables?: Record<string, {
|
|
726
|
+
default: string;
|
|
727
|
+
type?: string | undefined;
|
|
728
|
+
displayName?: string | undefined;
|
|
729
|
+
helpText?: string | undefined;
|
|
730
|
+
order?: number | undefined;
|
|
731
|
+
source?: string | undefined;
|
|
732
|
+
}> | undefined;
|
|
733
|
+
} & {
|
|
734
|
+
url: string;
|
|
735
|
+
}) | undefined;
|
|
736
|
+
}>>;
|
|
737
|
+
dataSourceVariant: z.ZodOptional<z.ZodEnum<["unpublished"]>>;
|
|
738
|
+
}, "displayName" | "variables" | "id" | "allowedOnComponents" | "badgeIconUrl" | "purgeKey" | "edgehancer">, "strip", z.ZodTypeAny, {
|
|
387
739
|
url: string;
|
|
740
|
+
connectorType: string;
|
|
388
741
|
method: "GET" | "POST" | "HEAD";
|
|
389
|
-
|
|
742
|
+
custom?: Record<string, unknown> | undefined;
|
|
390
743
|
headers?: {
|
|
391
744
|
key: string;
|
|
392
745
|
value: string;
|
|
@@ -397,17 +750,42 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
397
750
|
value: string;
|
|
398
751
|
omitIfEmpty?: boolean | undefined;
|
|
399
752
|
}[] | undefined;
|
|
753
|
+
archetype?: string | undefined;
|
|
400
754
|
body?: string | undefined;
|
|
401
|
-
custom?: Record<string, unknown> | undefined;
|
|
402
755
|
customPublic?: Record<string, unknown> | undefined;
|
|
403
756
|
ttl?: number | undefined;
|
|
404
757
|
localeMapping?: Record<string, string> | undefined;
|
|
405
758
|
uiBadgeText?: string | undefined;
|
|
759
|
+
variants?: {
|
|
760
|
+
unpublished?: ({
|
|
761
|
+
headers?: {
|
|
762
|
+
key: string;
|
|
763
|
+
value: string;
|
|
764
|
+
omitIfEmpty?: boolean | undefined;
|
|
765
|
+
}[] | undefined;
|
|
766
|
+
parameters?: {
|
|
767
|
+
key: string;
|
|
768
|
+
value: string;
|
|
769
|
+
omitIfEmpty?: boolean | undefined;
|
|
770
|
+
}[] | undefined;
|
|
771
|
+
variables?: Record<string, {
|
|
772
|
+
default: string;
|
|
773
|
+
type?: string | undefined;
|
|
774
|
+
displayName?: string | undefined;
|
|
775
|
+
helpText?: string | undefined;
|
|
776
|
+
order?: number | undefined;
|
|
777
|
+
source?: string | undefined;
|
|
778
|
+
}> | undefined;
|
|
779
|
+
} & {
|
|
780
|
+
url: string;
|
|
781
|
+
}) | undefined;
|
|
782
|
+
} | undefined;
|
|
783
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
406
784
|
}, {
|
|
407
|
-
connectorType: string;
|
|
408
785
|
url: string;
|
|
786
|
+
connectorType: string;
|
|
409
787
|
method: "GET" | "POST" | "HEAD";
|
|
410
|
-
|
|
788
|
+
custom?: Record<string, unknown> | undefined;
|
|
411
789
|
headers?: {
|
|
412
790
|
key: string;
|
|
413
791
|
value: string;
|
|
@@ -418,12 +796,37 @@ declare const edgehancerMergedDataTypeSchema: z.ZodObject<Omit<{
|
|
|
418
796
|
value: string;
|
|
419
797
|
omitIfEmpty?: boolean | undefined;
|
|
420
798
|
}[] | undefined;
|
|
799
|
+
archetype?: string | undefined;
|
|
421
800
|
body?: string | undefined;
|
|
422
|
-
custom?: Record<string, unknown> | undefined;
|
|
423
801
|
customPublic?: Record<string, unknown> | undefined;
|
|
424
802
|
ttl?: number | undefined;
|
|
425
803
|
localeMapping?: Record<string, string> | undefined;
|
|
426
804
|
uiBadgeText?: string | undefined;
|
|
805
|
+
variants?: {
|
|
806
|
+
unpublished?: ({
|
|
807
|
+
headers?: {
|
|
808
|
+
key: string;
|
|
809
|
+
value: string;
|
|
810
|
+
omitIfEmpty?: boolean | undefined;
|
|
811
|
+
}[] | undefined;
|
|
812
|
+
parameters?: {
|
|
813
|
+
key: string;
|
|
814
|
+
value: string;
|
|
815
|
+
omitIfEmpty?: boolean | undefined;
|
|
816
|
+
}[] | undefined;
|
|
817
|
+
variables?: Record<string, {
|
|
818
|
+
default: string;
|
|
819
|
+
type?: string | undefined;
|
|
820
|
+
displayName?: string | undefined;
|
|
821
|
+
helpText?: string | undefined;
|
|
822
|
+
order?: number | undefined;
|
|
823
|
+
source?: string | undefined;
|
|
824
|
+
}> | undefined;
|
|
825
|
+
} & {
|
|
826
|
+
url: string;
|
|
827
|
+
}) | undefined;
|
|
828
|
+
} | undefined;
|
|
829
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
427
830
|
}>;
|
|
428
831
|
type EdgehancerMergedDataType = z.infer<typeof edgehancerMergedDataTypeSchema>;
|
|
429
832
|
type PreRequestEdgehancerDataResourceContext = {
|
|
@@ -439,6 +842,10 @@ type PreRequestEdgehancerContext = {
|
|
|
439
842
|
* that the hook is registered for.
|
|
440
843
|
*/
|
|
441
844
|
dataResources: readonly PreRequestEdgehancerDataResourceContext[];
|
|
845
|
+
/**
|
|
846
|
+
* Which Data Source variant to use for the request. For example in case of "unpublished" variant PreRequest hook can change from Delivery API to Preview API and change authentication headers.
|
|
847
|
+
*/
|
|
848
|
+
dataSourceVariant?: DataSourceVariantsKeys;
|
|
442
849
|
};
|
|
443
850
|
declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
444
851
|
errors: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
|
|
@@ -518,11 +925,154 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
518
925
|
request?: string | undefined;
|
|
519
926
|
}>>;
|
|
520
927
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
521
|
-
|
|
522
|
-
|
|
928
|
+
variants: z.ZodOptional<z.ZodObject<{
|
|
929
|
+
unpublished: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
|
|
930
|
+
headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
931
|
+
key: z.ZodString;
|
|
932
|
+
value: z.ZodString;
|
|
933
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
934
|
+
}, "strip", z.ZodTypeAny, {
|
|
935
|
+
key: string;
|
|
936
|
+
value: string;
|
|
937
|
+
omitIfEmpty?: boolean | undefined;
|
|
938
|
+
}, {
|
|
939
|
+
key: string;
|
|
940
|
+
value: string;
|
|
941
|
+
omitIfEmpty?: boolean | undefined;
|
|
942
|
+
}>, "many">>;
|
|
943
|
+
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
944
|
+
key: z.ZodString;
|
|
945
|
+
value: z.ZodString;
|
|
946
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
947
|
+
}, "strip", z.ZodTypeAny, {
|
|
948
|
+
key: string;
|
|
949
|
+
value: string;
|
|
950
|
+
omitIfEmpty?: boolean | undefined;
|
|
951
|
+
}, {
|
|
952
|
+
key: string;
|
|
953
|
+
value: string;
|
|
954
|
+
omitIfEmpty?: boolean | undefined;
|
|
955
|
+
}>, "many">>;
|
|
956
|
+
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
957
|
+
displayName: z.ZodOptional<z.ZodString>;
|
|
958
|
+
type: z.ZodOptional<z.ZodString>;
|
|
959
|
+
default: z.ZodString;
|
|
960
|
+
helpText: z.ZodOptional<z.ZodString>;
|
|
961
|
+
order: z.ZodOptional<z.ZodNumber>;
|
|
962
|
+
source: z.ZodOptional<z.ZodString>;
|
|
963
|
+
}, "strip", z.ZodTypeAny, {
|
|
964
|
+
default: string;
|
|
965
|
+
type?: string | undefined;
|
|
966
|
+
displayName?: string | undefined;
|
|
967
|
+
helpText?: string | undefined;
|
|
968
|
+
order?: number | undefined;
|
|
969
|
+
source?: string | undefined;
|
|
970
|
+
}, {
|
|
971
|
+
default: string;
|
|
972
|
+
type?: string | undefined;
|
|
973
|
+
displayName?: string | undefined;
|
|
974
|
+
helpText?: string | undefined;
|
|
975
|
+
order?: number | undefined;
|
|
976
|
+
source?: string | undefined;
|
|
977
|
+
}>>>;
|
|
978
|
+
}, "strip", z.ZodTypeAny, {
|
|
979
|
+
headers?: {
|
|
980
|
+
key: string;
|
|
981
|
+
value: string;
|
|
982
|
+
omitIfEmpty?: boolean | undefined;
|
|
983
|
+
}[] | undefined;
|
|
984
|
+
parameters?: {
|
|
985
|
+
key: string;
|
|
986
|
+
value: string;
|
|
987
|
+
omitIfEmpty?: boolean | undefined;
|
|
988
|
+
}[] | undefined;
|
|
989
|
+
variables?: Record<string, {
|
|
990
|
+
default: string;
|
|
991
|
+
type?: string | undefined;
|
|
992
|
+
displayName?: string | undefined;
|
|
993
|
+
helpText?: string | undefined;
|
|
994
|
+
order?: number | undefined;
|
|
995
|
+
source?: string | undefined;
|
|
996
|
+
}> | undefined;
|
|
997
|
+
}, {
|
|
998
|
+
headers?: {
|
|
999
|
+
key: string;
|
|
1000
|
+
value: string;
|
|
1001
|
+
omitIfEmpty?: boolean | undefined;
|
|
1002
|
+
}[] | undefined;
|
|
1003
|
+
parameters?: {
|
|
1004
|
+
key: string;
|
|
1005
|
+
value: string;
|
|
1006
|
+
omitIfEmpty?: boolean | undefined;
|
|
1007
|
+
}[] | undefined;
|
|
1008
|
+
variables?: Record<string, {
|
|
1009
|
+
default: string;
|
|
1010
|
+
type?: string | undefined;
|
|
1011
|
+
displayName?: string | undefined;
|
|
1012
|
+
helpText?: string | undefined;
|
|
1013
|
+
order?: number | undefined;
|
|
1014
|
+
source?: string | undefined;
|
|
1015
|
+
}> | undefined;
|
|
1016
|
+
}>, z.ZodObject<{
|
|
1017
|
+
url: z.ZodString;
|
|
1018
|
+
}, "strip", z.ZodTypeAny, {
|
|
1019
|
+
url: string;
|
|
1020
|
+
}, {
|
|
1021
|
+
url: string;
|
|
1022
|
+
}>>>;
|
|
1023
|
+
}, "strip", z.ZodTypeAny, {
|
|
1024
|
+
unpublished?: ({
|
|
1025
|
+
headers?: {
|
|
1026
|
+
key: string;
|
|
1027
|
+
value: string;
|
|
1028
|
+
omitIfEmpty?: boolean | undefined;
|
|
1029
|
+
}[] | undefined;
|
|
1030
|
+
parameters?: {
|
|
1031
|
+
key: string;
|
|
1032
|
+
value: string;
|
|
1033
|
+
omitIfEmpty?: boolean | undefined;
|
|
1034
|
+
}[] | undefined;
|
|
1035
|
+
variables?: Record<string, {
|
|
1036
|
+
default: string;
|
|
1037
|
+
type?: string | undefined;
|
|
1038
|
+
displayName?: string | undefined;
|
|
1039
|
+
helpText?: string | undefined;
|
|
1040
|
+
order?: number | undefined;
|
|
1041
|
+
source?: string | undefined;
|
|
1042
|
+
}> | undefined;
|
|
1043
|
+
} & {
|
|
1044
|
+
url: string;
|
|
1045
|
+
}) | undefined;
|
|
1046
|
+
}, {
|
|
1047
|
+
unpublished?: ({
|
|
1048
|
+
headers?: {
|
|
1049
|
+
key: string;
|
|
1050
|
+
value: string;
|
|
1051
|
+
omitIfEmpty?: boolean | undefined;
|
|
1052
|
+
}[] | undefined;
|
|
1053
|
+
parameters?: {
|
|
1054
|
+
key: string;
|
|
1055
|
+
value: string;
|
|
1056
|
+
omitIfEmpty?: boolean | undefined;
|
|
1057
|
+
}[] | undefined;
|
|
1058
|
+
variables?: Record<string, {
|
|
1059
|
+
default: string;
|
|
1060
|
+
type?: string | undefined;
|
|
1061
|
+
displayName?: string | undefined;
|
|
1062
|
+
helpText?: string | undefined;
|
|
1063
|
+
order?: number | undefined;
|
|
1064
|
+
source?: string | undefined;
|
|
1065
|
+
}> | undefined;
|
|
1066
|
+
} & {
|
|
1067
|
+
url: string;
|
|
1068
|
+
}) | undefined;
|
|
1069
|
+
}>>;
|
|
1070
|
+
dataSourceVariant: z.ZodOptional<z.ZodEnum<["unpublished"]>>;
|
|
1071
|
+
}, "displayName" | "variables" | "id" | "allowedOnComponents" | "badgeIconUrl" | "purgeKey" | "edgehancer">, "strip", z.ZodTypeAny, {
|
|
523
1072
|
url: string;
|
|
1073
|
+
connectorType: string;
|
|
524
1074
|
method: "GET" | "POST" | "HEAD";
|
|
525
|
-
|
|
1075
|
+
custom?: Record<string, unknown> | undefined;
|
|
526
1076
|
headers?: {
|
|
527
1077
|
key: string;
|
|
528
1078
|
value: string;
|
|
@@ -533,17 +1083,42 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
533
1083
|
value: string;
|
|
534
1084
|
omitIfEmpty?: boolean | undefined;
|
|
535
1085
|
}[] | undefined;
|
|
1086
|
+
archetype?: string | undefined;
|
|
536
1087
|
body?: string | undefined;
|
|
537
|
-
custom?: Record<string, unknown> | undefined;
|
|
538
1088
|
customPublic?: Record<string, unknown> | undefined;
|
|
539
1089
|
ttl?: number | undefined;
|
|
540
1090
|
localeMapping?: Record<string, string> | undefined;
|
|
541
1091
|
uiBadgeText?: string | undefined;
|
|
1092
|
+
variants?: {
|
|
1093
|
+
unpublished?: ({
|
|
1094
|
+
headers?: {
|
|
1095
|
+
key: string;
|
|
1096
|
+
value: string;
|
|
1097
|
+
omitIfEmpty?: boolean | undefined;
|
|
1098
|
+
}[] | undefined;
|
|
1099
|
+
parameters?: {
|
|
1100
|
+
key: string;
|
|
1101
|
+
value: string;
|
|
1102
|
+
omitIfEmpty?: boolean | undefined;
|
|
1103
|
+
}[] | undefined;
|
|
1104
|
+
variables?: Record<string, {
|
|
1105
|
+
default: string;
|
|
1106
|
+
type?: string | undefined;
|
|
1107
|
+
displayName?: string | undefined;
|
|
1108
|
+
helpText?: string | undefined;
|
|
1109
|
+
order?: number | undefined;
|
|
1110
|
+
source?: string | undefined;
|
|
1111
|
+
}> | undefined;
|
|
1112
|
+
} & {
|
|
1113
|
+
url: string;
|
|
1114
|
+
}) | undefined;
|
|
1115
|
+
} | undefined;
|
|
1116
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
542
1117
|
}, {
|
|
543
|
-
connectorType: string;
|
|
544
1118
|
url: string;
|
|
1119
|
+
connectorType: string;
|
|
545
1120
|
method: "GET" | "POST" | "HEAD";
|
|
546
|
-
|
|
1121
|
+
custom?: Record<string, unknown> | undefined;
|
|
547
1122
|
headers?: {
|
|
548
1123
|
key: string;
|
|
549
1124
|
value: string;
|
|
@@ -554,19 +1129,44 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
554
1129
|
value: string;
|
|
555
1130
|
omitIfEmpty?: boolean | undefined;
|
|
556
1131
|
}[] | undefined;
|
|
1132
|
+
archetype?: string | undefined;
|
|
557
1133
|
body?: string | undefined;
|
|
558
|
-
custom?: Record<string, unknown> | undefined;
|
|
559
1134
|
customPublic?: Record<string, unknown> | undefined;
|
|
560
1135
|
ttl?: number | undefined;
|
|
561
1136
|
localeMapping?: Record<string, string> | undefined;
|
|
562
1137
|
uiBadgeText?: string | undefined;
|
|
1138
|
+
variants?: {
|
|
1139
|
+
unpublished?: ({
|
|
1140
|
+
headers?: {
|
|
1141
|
+
key: string;
|
|
1142
|
+
value: string;
|
|
1143
|
+
omitIfEmpty?: boolean | undefined;
|
|
1144
|
+
}[] | undefined;
|
|
1145
|
+
parameters?: {
|
|
1146
|
+
key: string;
|
|
1147
|
+
value: string;
|
|
1148
|
+
omitIfEmpty?: boolean | undefined;
|
|
1149
|
+
}[] | undefined;
|
|
1150
|
+
variables?: Record<string, {
|
|
1151
|
+
default: string;
|
|
1152
|
+
type?: string | undefined;
|
|
1153
|
+
displayName?: string | undefined;
|
|
1154
|
+
helpText?: string | undefined;
|
|
1155
|
+
order?: number | undefined;
|
|
1156
|
+
source?: string | undefined;
|
|
1157
|
+
}> | undefined;
|
|
1158
|
+
} & {
|
|
1159
|
+
url: string;
|
|
1160
|
+
}) | undefined;
|
|
1161
|
+
} | undefined;
|
|
1162
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
563
1163
|
}>;
|
|
564
1164
|
}, "strict", z.ZodTypeAny, {
|
|
565
1165
|
dataResource: {
|
|
566
|
-
connectorType: string;
|
|
567
1166
|
url: string;
|
|
1167
|
+
connectorType: string;
|
|
568
1168
|
method: "GET" | "POST" | "HEAD";
|
|
569
|
-
|
|
1169
|
+
custom?: Record<string, unknown> | undefined;
|
|
570
1170
|
headers?: {
|
|
571
1171
|
key: string;
|
|
572
1172
|
value: string;
|
|
@@ -577,22 +1177,47 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
577
1177
|
value: string;
|
|
578
1178
|
omitIfEmpty?: boolean | undefined;
|
|
579
1179
|
}[] | undefined;
|
|
1180
|
+
archetype?: string | undefined;
|
|
580
1181
|
body?: string | undefined;
|
|
581
|
-
custom?: Record<string, unknown> | undefined;
|
|
582
1182
|
customPublic?: Record<string, unknown> | undefined;
|
|
583
1183
|
ttl?: number | undefined;
|
|
584
1184
|
localeMapping?: Record<string, string> | undefined;
|
|
585
1185
|
uiBadgeText?: string | undefined;
|
|
1186
|
+
variants?: {
|
|
1187
|
+
unpublished?: ({
|
|
1188
|
+
headers?: {
|
|
1189
|
+
key: string;
|
|
1190
|
+
value: string;
|
|
1191
|
+
omitIfEmpty?: boolean | undefined;
|
|
1192
|
+
}[] | undefined;
|
|
1193
|
+
parameters?: {
|
|
1194
|
+
key: string;
|
|
1195
|
+
value: string;
|
|
1196
|
+
omitIfEmpty?: boolean | undefined;
|
|
1197
|
+
}[] | undefined;
|
|
1198
|
+
variables?: Record<string, {
|
|
1199
|
+
default: string;
|
|
1200
|
+
type?: string | undefined;
|
|
1201
|
+
displayName?: string | undefined;
|
|
1202
|
+
helpText?: string | undefined;
|
|
1203
|
+
order?: number | undefined;
|
|
1204
|
+
source?: string | undefined;
|
|
1205
|
+
}> | undefined;
|
|
1206
|
+
} & {
|
|
1207
|
+
url: string;
|
|
1208
|
+
}) | undefined;
|
|
1209
|
+
} | undefined;
|
|
1210
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
586
1211
|
};
|
|
587
1212
|
errors?: string[] | undefined;
|
|
588
1213
|
warnings?: string[] | undefined;
|
|
589
1214
|
infos?: string[] | undefined;
|
|
590
1215
|
}, {
|
|
591
1216
|
dataResource: {
|
|
592
|
-
connectorType: string;
|
|
593
1217
|
url: string;
|
|
1218
|
+
connectorType: string;
|
|
594
1219
|
method: "GET" | "POST" | "HEAD";
|
|
595
|
-
|
|
1220
|
+
custom?: Record<string, unknown> | undefined;
|
|
596
1221
|
headers?: {
|
|
597
1222
|
key: string;
|
|
598
1223
|
value: string;
|
|
@@ -603,12 +1228,37 @@ declare const preRequestEdgehancerDataResourceResultSchema: z.ZodObject<{
|
|
|
603
1228
|
value: string;
|
|
604
1229
|
omitIfEmpty?: boolean | undefined;
|
|
605
1230
|
}[] | undefined;
|
|
1231
|
+
archetype?: string | undefined;
|
|
606
1232
|
body?: string | undefined;
|
|
607
|
-
custom?: Record<string, unknown> | undefined;
|
|
608
1233
|
customPublic?: Record<string, unknown> | undefined;
|
|
609
1234
|
ttl?: number | undefined;
|
|
610
1235
|
localeMapping?: Record<string, string> | undefined;
|
|
611
1236
|
uiBadgeText?: string | undefined;
|
|
1237
|
+
variants?: {
|
|
1238
|
+
unpublished?: ({
|
|
1239
|
+
headers?: {
|
|
1240
|
+
key: string;
|
|
1241
|
+
value: string;
|
|
1242
|
+
omitIfEmpty?: boolean | undefined;
|
|
1243
|
+
}[] | undefined;
|
|
1244
|
+
parameters?: {
|
|
1245
|
+
key: string;
|
|
1246
|
+
value: string;
|
|
1247
|
+
omitIfEmpty?: boolean | undefined;
|
|
1248
|
+
}[] | undefined;
|
|
1249
|
+
variables?: Record<string, {
|
|
1250
|
+
default: string;
|
|
1251
|
+
type?: string | undefined;
|
|
1252
|
+
displayName?: string | undefined;
|
|
1253
|
+
helpText?: string | undefined;
|
|
1254
|
+
order?: number | undefined;
|
|
1255
|
+
source?: string | undefined;
|
|
1256
|
+
}> | undefined;
|
|
1257
|
+
} & {
|
|
1258
|
+
url: string;
|
|
1259
|
+
}) | undefined;
|
|
1260
|
+
} | undefined;
|
|
1261
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
612
1262
|
};
|
|
613
1263
|
errors?: string[] | undefined;
|
|
614
1264
|
warnings?: string[] | undefined;
|
|
@@ -693,11 +1343,154 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
693
1343
|
request?: string | undefined;
|
|
694
1344
|
}>>;
|
|
695
1345
|
uiBadgeText: z.ZodOptional<z.ZodString>;
|
|
696
|
-
|
|
697
|
-
|
|
1346
|
+
variants: z.ZodOptional<z.ZodObject<{
|
|
1347
|
+
unpublished: z.ZodOptional<z.ZodIntersection<z.ZodObject<{
|
|
1348
|
+
headers: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1349
|
+
key: z.ZodString;
|
|
1350
|
+
value: z.ZodString;
|
|
1351
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1352
|
+
}, "strip", z.ZodTypeAny, {
|
|
1353
|
+
key: string;
|
|
1354
|
+
value: string;
|
|
1355
|
+
omitIfEmpty?: boolean | undefined;
|
|
1356
|
+
}, {
|
|
1357
|
+
key: string;
|
|
1358
|
+
value: string;
|
|
1359
|
+
omitIfEmpty?: boolean | undefined;
|
|
1360
|
+
}>, "many">>;
|
|
1361
|
+
parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
|
|
1362
|
+
key: z.ZodString;
|
|
1363
|
+
value: z.ZodString;
|
|
1364
|
+
omitIfEmpty: z.ZodOptional<z.ZodBoolean>;
|
|
1365
|
+
}, "strip", z.ZodTypeAny, {
|
|
1366
|
+
key: string;
|
|
1367
|
+
value: string;
|
|
1368
|
+
omitIfEmpty?: boolean | undefined;
|
|
1369
|
+
}, {
|
|
1370
|
+
key: string;
|
|
1371
|
+
value: string;
|
|
1372
|
+
omitIfEmpty?: boolean | undefined;
|
|
1373
|
+
}>, "many">>;
|
|
1374
|
+
variables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
|
|
1375
|
+
displayName: z.ZodOptional<z.ZodString>;
|
|
1376
|
+
type: z.ZodOptional<z.ZodString>;
|
|
1377
|
+
default: z.ZodString;
|
|
1378
|
+
helpText: z.ZodOptional<z.ZodString>;
|
|
1379
|
+
order: z.ZodOptional<z.ZodNumber>;
|
|
1380
|
+
source: z.ZodOptional<z.ZodString>;
|
|
1381
|
+
}, "strip", z.ZodTypeAny, {
|
|
1382
|
+
default: string;
|
|
1383
|
+
type?: string | undefined;
|
|
1384
|
+
displayName?: string | undefined;
|
|
1385
|
+
helpText?: string | undefined;
|
|
1386
|
+
order?: number | undefined;
|
|
1387
|
+
source?: string | undefined;
|
|
1388
|
+
}, {
|
|
1389
|
+
default: string;
|
|
1390
|
+
type?: string | undefined;
|
|
1391
|
+
displayName?: string | undefined;
|
|
1392
|
+
helpText?: string | undefined;
|
|
1393
|
+
order?: number | undefined;
|
|
1394
|
+
source?: string | undefined;
|
|
1395
|
+
}>>>;
|
|
1396
|
+
}, "strip", z.ZodTypeAny, {
|
|
1397
|
+
headers?: {
|
|
1398
|
+
key: string;
|
|
1399
|
+
value: string;
|
|
1400
|
+
omitIfEmpty?: boolean | undefined;
|
|
1401
|
+
}[] | undefined;
|
|
1402
|
+
parameters?: {
|
|
1403
|
+
key: string;
|
|
1404
|
+
value: string;
|
|
1405
|
+
omitIfEmpty?: boolean | undefined;
|
|
1406
|
+
}[] | undefined;
|
|
1407
|
+
variables?: Record<string, {
|
|
1408
|
+
default: string;
|
|
1409
|
+
type?: string | undefined;
|
|
1410
|
+
displayName?: string | undefined;
|
|
1411
|
+
helpText?: string | undefined;
|
|
1412
|
+
order?: number | undefined;
|
|
1413
|
+
source?: string | undefined;
|
|
1414
|
+
}> | undefined;
|
|
1415
|
+
}, {
|
|
1416
|
+
headers?: {
|
|
1417
|
+
key: string;
|
|
1418
|
+
value: string;
|
|
1419
|
+
omitIfEmpty?: boolean | undefined;
|
|
1420
|
+
}[] | undefined;
|
|
1421
|
+
parameters?: {
|
|
1422
|
+
key: string;
|
|
1423
|
+
value: string;
|
|
1424
|
+
omitIfEmpty?: boolean | undefined;
|
|
1425
|
+
}[] | undefined;
|
|
1426
|
+
variables?: Record<string, {
|
|
1427
|
+
default: string;
|
|
1428
|
+
type?: string | undefined;
|
|
1429
|
+
displayName?: string | undefined;
|
|
1430
|
+
helpText?: string | undefined;
|
|
1431
|
+
order?: number | undefined;
|
|
1432
|
+
source?: string | undefined;
|
|
1433
|
+
}> | undefined;
|
|
1434
|
+
}>, z.ZodObject<{
|
|
1435
|
+
url: z.ZodString;
|
|
1436
|
+
}, "strip", z.ZodTypeAny, {
|
|
1437
|
+
url: string;
|
|
1438
|
+
}, {
|
|
1439
|
+
url: string;
|
|
1440
|
+
}>>>;
|
|
1441
|
+
}, "strip", z.ZodTypeAny, {
|
|
1442
|
+
unpublished?: ({
|
|
1443
|
+
headers?: {
|
|
1444
|
+
key: string;
|
|
1445
|
+
value: string;
|
|
1446
|
+
omitIfEmpty?: boolean | undefined;
|
|
1447
|
+
}[] | undefined;
|
|
1448
|
+
parameters?: {
|
|
1449
|
+
key: string;
|
|
1450
|
+
value: string;
|
|
1451
|
+
omitIfEmpty?: boolean | undefined;
|
|
1452
|
+
}[] | undefined;
|
|
1453
|
+
variables?: Record<string, {
|
|
1454
|
+
default: string;
|
|
1455
|
+
type?: string | undefined;
|
|
1456
|
+
displayName?: string | undefined;
|
|
1457
|
+
helpText?: string | undefined;
|
|
1458
|
+
order?: number | undefined;
|
|
1459
|
+
source?: string | undefined;
|
|
1460
|
+
}> | undefined;
|
|
1461
|
+
} & {
|
|
1462
|
+
url: string;
|
|
1463
|
+
}) | undefined;
|
|
1464
|
+
}, {
|
|
1465
|
+
unpublished?: ({
|
|
1466
|
+
headers?: {
|
|
1467
|
+
key: string;
|
|
1468
|
+
value: string;
|
|
1469
|
+
omitIfEmpty?: boolean | undefined;
|
|
1470
|
+
}[] | undefined;
|
|
1471
|
+
parameters?: {
|
|
1472
|
+
key: string;
|
|
1473
|
+
value: string;
|
|
1474
|
+
omitIfEmpty?: boolean | undefined;
|
|
1475
|
+
}[] | undefined;
|
|
1476
|
+
variables?: Record<string, {
|
|
1477
|
+
default: string;
|
|
1478
|
+
type?: string | undefined;
|
|
1479
|
+
displayName?: string | undefined;
|
|
1480
|
+
helpText?: string | undefined;
|
|
1481
|
+
order?: number | undefined;
|
|
1482
|
+
source?: string | undefined;
|
|
1483
|
+
}> | undefined;
|
|
1484
|
+
} & {
|
|
1485
|
+
url: string;
|
|
1486
|
+
}) | undefined;
|
|
1487
|
+
}>>;
|
|
1488
|
+
dataSourceVariant: z.ZodOptional<z.ZodEnum<["unpublished"]>>;
|
|
1489
|
+
}, "displayName" | "variables" | "id" | "allowedOnComponents" | "badgeIconUrl" | "purgeKey" | "edgehancer">, "strip", z.ZodTypeAny, {
|
|
698
1490
|
url: string;
|
|
1491
|
+
connectorType: string;
|
|
699
1492
|
method: "GET" | "POST" | "HEAD";
|
|
700
|
-
|
|
1493
|
+
custom?: Record<string, unknown> | undefined;
|
|
701
1494
|
headers?: {
|
|
702
1495
|
key: string;
|
|
703
1496
|
value: string;
|
|
@@ -708,17 +1501,42 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
708
1501
|
value: string;
|
|
709
1502
|
omitIfEmpty?: boolean | undefined;
|
|
710
1503
|
}[] | undefined;
|
|
1504
|
+
archetype?: string | undefined;
|
|
711
1505
|
body?: string | undefined;
|
|
712
|
-
custom?: Record<string, unknown> | undefined;
|
|
713
1506
|
customPublic?: Record<string, unknown> | undefined;
|
|
714
1507
|
ttl?: number | undefined;
|
|
715
1508
|
localeMapping?: Record<string, string> | undefined;
|
|
716
1509
|
uiBadgeText?: string | undefined;
|
|
1510
|
+
variants?: {
|
|
1511
|
+
unpublished?: ({
|
|
1512
|
+
headers?: {
|
|
1513
|
+
key: string;
|
|
1514
|
+
value: string;
|
|
1515
|
+
omitIfEmpty?: boolean | undefined;
|
|
1516
|
+
}[] | undefined;
|
|
1517
|
+
parameters?: {
|
|
1518
|
+
key: string;
|
|
1519
|
+
value: string;
|
|
1520
|
+
omitIfEmpty?: boolean | undefined;
|
|
1521
|
+
}[] | undefined;
|
|
1522
|
+
variables?: Record<string, {
|
|
1523
|
+
default: string;
|
|
1524
|
+
type?: string | undefined;
|
|
1525
|
+
displayName?: string | undefined;
|
|
1526
|
+
helpText?: string | undefined;
|
|
1527
|
+
order?: number | undefined;
|
|
1528
|
+
source?: string | undefined;
|
|
1529
|
+
}> | undefined;
|
|
1530
|
+
} & {
|
|
1531
|
+
url: string;
|
|
1532
|
+
}) | undefined;
|
|
1533
|
+
} | undefined;
|
|
1534
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
717
1535
|
}, {
|
|
718
|
-
connectorType: string;
|
|
719
1536
|
url: string;
|
|
1537
|
+
connectorType: string;
|
|
720
1538
|
method: "GET" | "POST" | "HEAD";
|
|
721
|
-
|
|
1539
|
+
custom?: Record<string, unknown> | undefined;
|
|
722
1540
|
headers?: {
|
|
723
1541
|
key: string;
|
|
724
1542
|
value: string;
|
|
@@ -729,19 +1547,44 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
729
1547
|
value: string;
|
|
730
1548
|
omitIfEmpty?: boolean | undefined;
|
|
731
1549
|
}[] | undefined;
|
|
1550
|
+
archetype?: string | undefined;
|
|
732
1551
|
body?: string | undefined;
|
|
733
|
-
custom?: Record<string, unknown> | undefined;
|
|
734
1552
|
customPublic?: Record<string, unknown> | undefined;
|
|
735
1553
|
ttl?: number | undefined;
|
|
736
1554
|
localeMapping?: Record<string, string> | undefined;
|
|
737
1555
|
uiBadgeText?: string | undefined;
|
|
1556
|
+
variants?: {
|
|
1557
|
+
unpublished?: ({
|
|
1558
|
+
headers?: {
|
|
1559
|
+
key: string;
|
|
1560
|
+
value: string;
|
|
1561
|
+
omitIfEmpty?: boolean | undefined;
|
|
1562
|
+
}[] | undefined;
|
|
1563
|
+
parameters?: {
|
|
1564
|
+
key: string;
|
|
1565
|
+
value: string;
|
|
1566
|
+
omitIfEmpty?: boolean | undefined;
|
|
1567
|
+
}[] | undefined;
|
|
1568
|
+
variables?: Record<string, {
|
|
1569
|
+
default: string;
|
|
1570
|
+
type?: string | undefined;
|
|
1571
|
+
displayName?: string | undefined;
|
|
1572
|
+
helpText?: string | undefined;
|
|
1573
|
+
order?: number | undefined;
|
|
1574
|
+
source?: string | undefined;
|
|
1575
|
+
}> | undefined;
|
|
1576
|
+
} & {
|
|
1577
|
+
url: string;
|
|
1578
|
+
}) | undefined;
|
|
1579
|
+
} | undefined;
|
|
1580
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
738
1581
|
}>;
|
|
739
1582
|
}, "strict", z.ZodTypeAny, {
|
|
740
1583
|
dataResource: {
|
|
741
|
-
connectorType: string;
|
|
742
1584
|
url: string;
|
|
1585
|
+
connectorType: string;
|
|
743
1586
|
method: "GET" | "POST" | "HEAD";
|
|
744
|
-
|
|
1587
|
+
custom?: Record<string, unknown> | undefined;
|
|
745
1588
|
headers?: {
|
|
746
1589
|
key: string;
|
|
747
1590
|
value: string;
|
|
@@ -752,22 +1595,47 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
752
1595
|
value: string;
|
|
753
1596
|
omitIfEmpty?: boolean | undefined;
|
|
754
1597
|
}[] | undefined;
|
|
1598
|
+
archetype?: string | undefined;
|
|
755
1599
|
body?: string | undefined;
|
|
756
|
-
custom?: Record<string, unknown> | undefined;
|
|
757
1600
|
customPublic?: Record<string, unknown> | undefined;
|
|
758
1601
|
ttl?: number | undefined;
|
|
759
1602
|
localeMapping?: Record<string, string> | undefined;
|
|
760
1603
|
uiBadgeText?: string | undefined;
|
|
1604
|
+
variants?: {
|
|
1605
|
+
unpublished?: ({
|
|
1606
|
+
headers?: {
|
|
1607
|
+
key: string;
|
|
1608
|
+
value: string;
|
|
1609
|
+
omitIfEmpty?: boolean | undefined;
|
|
1610
|
+
}[] | undefined;
|
|
1611
|
+
parameters?: {
|
|
1612
|
+
key: string;
|
|
1613
|
+
value: string;
|
|
1614
|
+
omitIfEmpty?: boolean | undefined;
|
|
1615
|
+
}[] | undefined;
|
|
1616
|
+
variables?: Record<string, {
|
|
1617
|
+
default: string;
|
|
1618
|
+
type?: string | undefined;
|
|
1619
|
+
displayName?: string | undefined;
|
|
1620
|
+
helpText?: string | undefined;
|
|
1621
|
+
order?: number | undefined;
|
|
1622
|
+
source?: string | undefined;
|
|
1623
|
+
}> | undefined;
|
|
1624
|
+
} & {
|
|
1625
|
+
url: string;
|
|
1626
|
+
}) | undefined;
|
|
1627
|
+
} | undefined;
|
|
1628
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
761
1629
|
};
|
|
762
1630
|
errors?: string[] | undefined;
|
|
763
1631
|
warnings?: string[] | undefined;
|
|
764
1632
|
infos?: string[] | undefined;
|
|
765
1633
|
}, {
|
|
766
1634
|
dataResource: {
|
|
767
|
-
connectorType: string;
|
|
768
1635
|
url: string;
|
|
1636
|
+
connectorType: string;
|
|
769
1637
|
method: "GET" | "POST" | "HEAD";
|
|
770
|
-
|
|
1638
|
+
custom?: Record<string, unknown> | undefined;
|
|
771
1639
|
headers?: {
|
|
772
1640
|
key: string;
|
|
773
1641
|
value: string;
|
|
@@ -778,12 +1646,37 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
778
1646
|
value: string;
|
|
779
1647
|
omitIfEmpty?: boolean | undefined;
|
|
780
1648
|
}[] | undefined;
|
|
1649
|
+
archetype?: string | undefined;
|
|
781
1650
|
body?: string | undefined;
|
|
782
|
-
custom?: Record<string, unknown> | undefined;
|
|
783
1651
|
customPublic?: Record<string, unknown> | undefined;
|
|
784
1652
|
ttl?: number | undefined;
|
|
785
1653
|
localeMapping?: Record<string, string> | undefined;
|
|
786
1654
|
uiBadgeText?: string | undefined;
|
|
1655
|
+
variants?: {
|
|
1656
|
+
unpublished?: ({
|
|
1657
|
+
headers?: {
|
|
1658
|
+
key: string;
|
|
1659
|
+
value: string;
|
|
1660
|
+
omitIfEmpty?: boolean | undefined;
|
|
1661
|
+
}[] | undefined;
|
|
1662
|
+
parameters?: {
|
|
1663
|
+
key: string;
|
|
1664
|
+
value: string;
|
|
1665
|
+
omitIfEmpty?: boolean | undefined;
|
|
1666
|
+
}[] | undefined;
|
|
1667
|
+
variables?: Record<string, {
|
|
1668
|
+
default: string;
|
|
1669
|
+
type?: string | undefined;
|
|
1670
|
+
displayName?: string | undefined;
|
|
1671
|
+
helpText?: string | undefined;
|
|
1672
|
+
order?: number | undefined;
|
|
1673
|
+
source?: string | undefined;
|
|
1674
|
+
}> | undefined;
|
|
1675
|
+
} & {
|
|
1676
|
+
url: string;
|
|
1677
|
+
}) | undefined;
|
|
1678
|
+
} | undefined;
|
|
1679
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
787
1680
|
};
|
|
788
1681
|
errors?: string[] | undefined;
|
|
789
1682
|
warnings?: string[] | undefined;
|
|
@@ -792,10 +1685,10 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
792
1685
|
}, "strict", z.ZodTypeAny, {
|
|
793
1686
|
dataResources: {
|
|
794
1687
|
dataResource: {
|
|
795
|
-
connectorType: string;
|
|
796
1688
|
url: string;
|
|
1689
|
+
connectorType: string;
|
|
797
1690
|
method: "GET" | "POST" | "HEAD";
|
|
798
|
-
|
|
1691
|
+
custom?: Record<string, unknown> | undefined;
|
|
799
1692
|
headers?: {
|
|
800
1693
|
key: string;
|
|
801
1694
|
value: string;
|
|
@@ -806,12 +1699,37 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
806
1699
|
value: string;
|
|
807
1700
|
omitIfEmpty?: boolean | undefined;
|
|
808
1701
|
}[] | undefined;
|
|
1702
|
+
archetype?: string | undefined;
|
|
809
1703
|
body?: string | undefined;
|
|
810
|
-
custom?: Record<string, unknown> | undefined;
|
|
811
1704
|
customPublic?: Record<string, unknown> | undefined;
|
|
812
1705
|
ttl?: number | undefined;
|
|
813
1706
|
localeMapping?: Record<string, string> | undefined;
|
|
814
1707
|
uiBadgeText?: string | undefined;
|
|
1708
|
+
variants?: {
|
|
1709
|
+
unpublished?: ({
|
|
1710
|
+
headers?: {
|
|
1711
|
+
key: string;
|
|
1712
|
+
value: string;
|
|
1713
|
+
omitIfEmpty?: boolean | undefined;
|
|
1714
|
+
}[] | undefined;
|
|
1715
|
+
parameters?: {
|
|
1716
|
+
key: string;
|
|
1717
|
+
value: string;
|
|
1718
|
+
omitIfEmpty?: boolean | undefined;
|
|
1719
|
+
}[] | undefined;
|
|
1720
|
+
variables?: Record<string, {
|
|
1721
|
+
default: string;
|
|
1722
|
+
type?: string | undefined;
|
|
1723
|
+
displayName?: string | undefined;
|
|
1724
|
+
helpText?: string | undefined;
|
|
1725
|
+
order?: number | undefined;
|
|
1726
|
+
source?: string | undefined;
|
|
1727
|
+
}> | undefined;
|
|
1728
|
+
} & {
|
|
1729
|
+
url: string;
|
|
1730
|
+
}) | undefined;
|
|
1731
|
+
} | undefined;
|
|
1732
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
815
1733
|
};
|
|
816
1734
|
errors?: string[] | undefined;
|
|
817
1735
|
warnings?: string[] | undefined;
|
|
@@ -820,10 +1738,10 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
820
1738
|
}, {
|
|
821
1739
|
dataResources: {
|
|
822
1740
|
dataResource: {
|
|
823
|
-
connectorType: string;
|
|
824
1741
|
url: string;
|
|
1742
|
+
connectorType: string;
|
|
825
1743
|
method: "GET" | "POST" | "HEAD";
|
|
826
|
-
|
|
1744
|
+
custom?: Record<string, unknown> | undefined;
|
|
827
1745
|
headers?: {
|
|
828
1746
|
key: string;
|
|
829
1747
|
value: string;
|
|
@@ -834,12 +1752,37 @@ declare const preRequestEdgehancerResultSchema: z.ZodObject<{
|
|
|
834
1752
|
value: string;
|
|
835
1753
|
omitIfEmpty?: boolean | undefined;
|
|
836
1754
|
}[] | undefined;
|
|
1755
|
+
archetype?: string | undefined;
|
|
837
1756
|
body?: string | undefined;
|
|
838
|
-
custom?: Record<string, unknown> | undefined;
|
|
839
1757
|
customPublic?: Record<string, unknown> | undefined;
|
|
840
1758
|
ttl?: number | undefined;
|
|
841
1759
|
localeMapping?: Record<string, string> | undefined;
|
|
842
1760
|
uiBadgeText?: string | undefined;
|
|
1761
|
+
variants?: {
|
|
1762
|
+
unpublished?: ({
|
|
1763
|
+
headers?: {
|
|
1764
|
+
key: string;
|
|
1765
|
+
value: string;
|
|
1766
|
+
omitIfEmpty?: boolean | undefined;
|
|
1767
|
+
}[] | undefined;
|
|
1768
|
+
parameters?: {
|
|
1769
|
+
key: string;
|
|
1770
|
+
value: string;
|
|
1771
|
+
omitIfEmpty?: boolean | undefined;
|
|
1772
|
+
}[] | undefined;
|
|
1773
|
+
variables?: Record<string, {
|
|
1774
|
+
default: string;
|
|
1775
|
+
type?: string | undefined;
|
|
1776
|
+
displayName?: string | undefined;
|
|
1777
|
+
helpText?: string | undefined;
|
|
1778
|
+
order?: number | undefined;
|
|
1779
|
+
source?: string | undefined;
|
|
1780
|
+
}> | undefined;
|
|
1781
|
+
} & {
|
|
1782
|
+
url: string;
|
|
1783
|
+
}) | undefined;
|
|
1784
|
+
} | undefined;
|
|
1785
|
+
dataSourceVariant?: "unpublished" | undefined;
|
|
843
1786
|
};
|
|
844
1787
|
errors?: string[] | undefined;
|
|
845
1788
|
warnings?: string[] | undefined;
|