@milaboratories/pl-model-middle-layer 1.4.0 → 1.4.2
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/block_meta/block_components.d.ts +212 -38
- package/dist/block_meta/block_components.d.ts.map +1 -1
- package/dist/block_meta/block_description.d.ts +174 -20
- package/dist/block_meta/block_description.d.ts.map +1 -1
- package/dist/block_meta/block_manifest.d.ts +234 -30
- package/dist/block_meta/block_manifest.d.ts.map +1 -1
- package/dist/block_meta/block_meta.d.ts +65 -0
- package/dist/block_meta/block_meta.d.ts.map +1 -1
- package/dist/block_registry/overview.d.ts +12 -0
- package/dist/block_registry/overview.d.ts.map +1 -1
- package/dist/index.js +1 -1
- package/dist/index.js.map +1 -1
- package/dist/index.mjs +114 -111
- package/dist/index.mjs.map +1 -1
- package/package.json +1 -1
- package/src/block_meta/block_components.ts +14 -10
- package/src/block_meta/block_meta.ts +1 -0
|
@@ -1,9 +1,40 @@
|
|
|
1
1
|
import { z } from 'zod';
|
|
2
2
|
export type BlockPackComponents = {};
|
|
3
|
-
export declare function
|
|
4
|
-
type:
|
|
5
|
-
main:
|
|
6
|
-
},
|
|
3
|
+
export declare function WorkflowV1<const Content extends z.ZodTypeAny>(contentType: Content): z.ZodObject<{
|
|
4
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
5
|
+
main: Content;
|
|
6
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
7
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
8
|
+
main: Content;
|
|
9
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
10
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
11
|
+
main: Content;
|
|
12
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
13
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
14
|
+
main: Content;
|
|
15
|
+
}>]: z.baseObjectInputType<{
|
|
16
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
17
|
+
main: Content;
|
|
18
|
+
}>[k_1]; }>;
|
|
19
|
+
export declare function Workflow<const Content extends z.ZodTypeAny>(contentType: Content): z.ZodUnion<[z.ZodPipeline<z.ZodEffects<Content, {
|
|
20
|
+
type: "workflow-v1";
|
|
21
|
+
main: z.TypeOf<Content>;
|
|
22
|
+
}, z.input<Content>>, z.ZodObject<{
|
|
23
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
24
|
+
main: Content;
|
|
25
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
26
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
27
|
+
main: Content;
|
|
28
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
29
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
30
|
+
main: Content;
|
|
31
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
32
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
33
|
+
main: Content;
|
|
34
|
+
}>]: z.baseObjectInputType<{
|
|
35
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
36
|
+
main: Content;
|
|
37
|
+
}>[k_1]; }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
7
38
|
type: z.ZodLiteral<"workflow-v1">;
|
|
8
39
|
main: Content;
|
|
9
40
|
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
@@ -20,10 +51,25 @@ export declare function Workflow<const Content extends z.ZodTypeAny>(contentType
|
|
|
20
51
|
main: Content;
|
|
21
52
|
}>[k_1]; }>]>]>;
|
|
22
53
|
export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, const UI extends z.ZodTypeAny>(wfAndModel: WfAndModel, ui: UI): z.ZodObject<{
|
|
23
|
-
workflow: z.ZodUnion<[z.ZodEffects<WfAndModel, {
|
|
24
|
-
type:
|
|
25
|
-
main:
|
|
26
|
-
}, z.input<WfAndModel>>, z.
|
|
54
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
|
|
55
|
+
type: "workflow-v1";
|
|
56
|
+
main: z.TypeOf<WfAndModel>;
|
|
57
|
+
}, z.input<WfAndModel>>, z.ZodObject<{
|
|
58
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
59
|
+
main: WfAndModel;
|
|
60
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
61
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
62
|
+
main: WfAndModel;
|
|
63
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
64
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
65
|
+
main: WfAndModel;
|
|
66
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
67
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
68
|
+
main: WfAndModel;
|
|
69
|
+
}>]: z.baseObjectInputType<{
|
|
70
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
71
|
+
main: WfAndModel;
|
|
72
|
+
}>[k_1]; }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
27
73
|
type: z.ZodLiteral<"workflow-v1">;
|
|
28
74
|
main: WfAndModel;
|
|
29
75
|
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
@@ -42,10 +88,25 @@ export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, c
|
|
|
42
88
|
model: WfAndModel;
|
|
43
89
|
ui: UI;
|
|
44
90
|
}, "strip", z.ZodTypeAny, { [k_2 in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
45
|
-
workflow: z.ZodUnion<[z.ZodEffects<WfAndModel, {
|
|
46
|
-
type:
|
|
47
|
-
main:
|
|
48
|
-
}, z.input<WfAndModel>>, z.
|
|
91
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
|
|
92
|
+
type: "workflow-v1";
|
|
93
|
+
main: z.TypeOf<WfAndModel>;
|
|
94
|
+
}, z.input<WfAndModel>>, z.ZodObject<{
|
|
95
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
96
|
+
main: WfAndModel;
|
|
97
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
98
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
99
|
+
main: WfAndModel;
|
|
100
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
101
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
102
|
+
main: WfAndModel;
|
|
103
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
104
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
105
|
+
main: WfAndModel;
|
|
106
|
+
}>]: z.baseObjectInputType<{
|
|
107
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
108
|
+
main: WfAndModel;
|
|
109
|
+
}>[k_1]; }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
49
110
|
type: z.ZodLiteral<"workflow-v1">;
|
|
50
111
|
main: WfAndModel;
|
|
51
112
|
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
@@ -64,10 +125,25 @@ export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, c
|
|
|
64
125
|
model: WfAndModel;
|
|
65
126
|
ui: UI;
|
|
66
127
|
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
67
|
-
workflow: z.ZodUnion<[z.ZodEffects<WfAndModel, {
|
|
68
|
-
type:
|
|
69
|
-
main:
|
|
70
|
-
}, z.input<WfAndModel>>, z.
|
|
128
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
|
|
129
|
+
type: "workflow-v1";
|
|
130
|
+
main: z.TypeOf<WfAndModel>;
|
|
131
|
+
}, z.input<WfAndModel>>, z.ZodObject<{
|
|
132
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
133
|
+
main: WfAndModel;
|
|
134
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
135
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
136
|
+
main: WfAndModel;
|
|
137
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
138
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
139
|
+
main: WfAndModel;
|
|
140
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
141
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
142
|
+
main: WfAndModel;
|
|
143
|
+
}>]: z.baseObjectInputType<{
|
|
144
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
145
|
+
main: WfAndModel;
|
|
146
|
+
}>[k_1]; }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
71
147
|
type: z.ZodLiteral<"workflow-v1">;
|
|
72
148
|
main: WfAndModel;
|
|
73
149
|
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
@@ -86,10 +162,25 @@ export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, c
|
|
|
86
162
|
model: WfAndModel;
|
|
87
163
|
ui: UI;
|
|
88
164
|
}>, any>[k_2]; }, { [k_1_1 in keyof z.baseObjectInputType<{
|
|
89
|
-
workflow: z.ZodUnion<[z.ZodEffects<WfAndModel, {
|
|
90
|
-
type:
|
|
91
|
-
main:
|
|
92
|
-
}, z.input<WfAndModel>>, z.
|
|
165
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
|
|
166
|
+
type: "workflow-v1";
|
|
167
|
+
main: z.TypeOf<WfAndModel>;
|
|
168
|
+
}, z.input<WfAndModel>>, z.ZodObject<{
|
|
169
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
170
|
+
main: WfAndModel;
|
|
171
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
172
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
173
|
+
main: WfAndModel;
|
|
174
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
175
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
176
|
+
main: WfAndModel;
|
|
177
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
178
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
179
|
+
main: WfAndModel;
|
|
180
|
+
}>]: z.baseObjectInputType<{
|
|
181
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
182
|
+
main: WfAndModel;
|
|
183
|
+
}>[k_1]; }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
93
184
|
type: z.ZodLiteral<"workflow-v1">;
|
|
94
185
|
main: WfAndModel;
|
|
95
186
|
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
@@ -108,10 +199,25 @@ export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, c
|
|
|
108
199
|
model: WfAndModel;
|
|
109
200
|
ui: UI;
|
|
110
201
|
}>]: z.baseObjectInputType<{
|
|
111
|
-
workflow: z.ZodUnion<[z.ZodEffects<WfAndModel, {
|
|
112
|
-
type:
|
|
113
|
-
main:
|
|
114
|
-
}, z.input<WfAndModel>>, z.
|
|
202
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<WfAndModel, {
|
|
203
|
+
type: "workflow-v1";
|
|
204
|
+
main: z.TypeOf<WfAndModel>;
|
|
205
|
+
}, z.input<WfAndModel>>, z.ZodObject<{
|
|
206
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
207
|
+
main: WfAndModel;
|
|
208
|
+
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
209
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
210
|
+
main: WfAndModel;
|
|
211
|
+
}>, any>]: z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
212
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
213
|
+
main: WfAndModel;
|
|
214
|
+
}>, any>[k]; }, { [k_1 in keyof z.baseObjectInputType<{
|
|
215
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
216
|
+
main: WfAndModel;
|
|
217
|
+
}>]: z.baseObjectInputType<{
|
|
218
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
219
|
+
main: WfAndModel;
|
|
220
|
+
}>[k_1]; }>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
115
221
|
type: z.ZodLiteral<"workflow-v1">;
|
|
116
222
|
main: WfAndModel;
|
|
117
223
|
}, "strip", z.ZodTypeAny, { [k in keyof z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
|
|
@@ -131,10 +237,19 @@ export declare function BlockComponents<const WfAndModel extends z.ZodTypeAny, c
|
|
|
131
237
|
ui: UI;
|
|
132
238
|
}>[k_1_1]; }>;
|
|
133
239
|
export declare const BlockComponentsDescriptionRaw: z.ZodObject<{
|
|
134
|
-
workflow: z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
135
|
-
type:
|
|
136
|
-
main:
|
|
137
|
-
}, string>, z.
|
|
240
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<z.ZodString, {
|
|
241
|
+
type: "workflow-v1";
|
|
242
|
+
main: string;
|
|
243
|
+
}, string>, z.ZodObject<{
|
|
244
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
245
|
+
main: z.ZodString;
|
|
246
|
+
}, "strip", z.ZodTypeAny, {
|
|
247
|
+
type: "workflow-v1";
|
|
248
|
+
main: string;
|
|
249
|
+
}, {
|
|
250
|
+
type: "workflow-v1";
|
|
251
|
+
main: string;
|
|
252
|
+
}>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
138
253
|
type: z.ZodLiteral<"workflow-v1">;
|
|
139
254
|
main: z.ZodString;
|
|
140
255
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -148,9 +263,6 @@ export declare const BlockComponentsDescriptionRaw: z.ZodObject<{
|
|
|
148
263
|
ui: z.ZodString;
|
|
149
264
|
}, "strip", z.ZodTypeAny, {
|
|
150
265
|
workflow: {
|
|
151
|
-
type: string;
|
|
152
|
-
main: any;
|
|
153
|
-
} | {
|
|
154
266
|
type: "workflow-v1";
|
|
155
267
|
main: string;
|
|
156
268
|
};
|
|
@@ -166,7 +278,7 @@ export declare const BlockComponentsDescriptionRaw: z.ZodObject<{
|
|
|
166
278
|
}>;
|
|
167
279
|
export type BlockComponentsDescriptionRaw = z.infer<typeof BlockComponentsDescriptionRaw>;
|
|
168
280
|
export declare function BlockComponentsAbsoluteUrl(prefix: string): z.ZodObject<{
|
|
169
|
-
workflow: z.ZodUnion<[z.ZodEffects<z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
281
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
170
282
|
type: z.ZodLiteral<"explicit-base64">;
|
|
171
283
|
mimeType: z.ZodString;
|
|
172
284
|
content: z.ZodString;
|
|
@@ -202,8 +314,15 @@ export declare function BlockComponentsAbsoluteUrl(prefix: string): z.ZodObject<
|
|
|
202
314
|
type: "relative";
|
|
203
315
|
path: string;
|
|
204
316
|
}>, {
|
|
205
|
-
type:
|
|
206
|
-
main:
|
|
317
|
+
type: "workflow-v1";
|
|
318
|
+
main: {
|
|
319
|
+
type: "explicit-base64";
|
|
320
|
+
content: string;
|
|
321
|
+
mimeType: string;
|
|
322
|
+
} | {
|
|
323
|
+
type: "absolute-url";
|
|
324
|
+
url: string;
|
|
325
|
+
};
|
|
207
326
|
}, {
|
|
208
327
|
type: "explicit-base64";
|
|
209
328
|
content: string;
|
|
@@ -211,7 +330,65 @@ export declare function BlockComponentsAbsoluteUrl(prefix: string): z.ZodObject<
|
|
|
211
330
|
} | {
|
|
212
331
|
type: "relative";
|
|
213
332
|
path: string;
|
|
214
|
-
}>, z.
|
|
333
|
+
}>, z.ZodObject<{
|
|
334
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
335
|
+
main: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
336
|
+
type: z.ZodLiteral<"explicit-base64">;
|
|
337
|
+
mimeType: z.ZodString;
|
|
338
|
+
content: z.ZodString;
|
|
339
|
+
}, "strict", z.ZodTypeAny, {
|
|
340
|
+
type: "explicit-base64";
|
|
341
|
+
content: string;
|
|
342
|
+
mimeType: string;
|
|
343
|
+
}, {
|
|
344
|
+
type: "explicit-base64";
|
|
345
|
+
content: string;
|
|
346
|
+
mimeType: string;
|
|
347
|
+
}>, z.ZodObject<{
|
|
348
|
+
type: z.ZodLiteral<"relative">;
|
|
349
|
+
path: z.ZodString;
|
|
350
|
+
}, "strict", z.ZodTypeAny, {
|
|
351
|
+
type: "relative";
|
|
352
|
+
path: string;
|
|
353
|
+
}, {
|
|
354
|
+
type: "relative";
|
|
355
|
+
path: string;
|
|
356
|
+
}>]>, {
|
|
357
|
+
type: "explicit-base64";
|
|
358
|
+
content: string;
|
|
359
|
+
mimeType: string;
|
|
360
|
+
} | {
|
|
361
|
+
type: "absolute-url";
|
|
362
|
+
url: string;
|
|
363
|
+
}, {
|
|
364
|
+
type: "explicit-base64";
|
|
365
|
+
content: string;
|
|
366
|
+
mimeType: string;
|
|
367
|
+
} | {
|
|
368
|
+
type: "relative";
|
|
369
|
+
path: string;
|
|
370
|
+
}>;
|
|
371
|
+
}, "strip", z.ZodTypeAny, {
|
|
372
|
+
type: "workflow-v1";
|
|
373
|
+
main: {
|
|
374
|
+
type: "explicit-base64";
|
|
375
|
+
content: string;
|
|
376
|
+
mimeType: string;
|
|
377
|
+
} | {
|
|
378
|
+
type: "absolute-url";
|
|
379
|
+
url: string;
|
|
380
|
+
};
|
|
381
|
+
}, {
|
|
382
|
+
type: "workflow-v1";
|
|
383
|
+
main: {
|
|
384
|
+
type: "explicit-base64";
|
|
385
|
+
content: string;
|
|
386
|
+
mimeType: string;
|
|
387
|
+
} | {
|
|
388
|
+
type: "relative";
|
|
389
|
+
path: string;
|
|
390
|
+
};
|
|
391
|
+
}>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
215
392
|
type: z.ZodLiteral<"workflow-v1">;
|
|
216
393
|
main: z.ZodEffects<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
217
394
|
type: z.ZodLiteral<"explicit-base64">;
|
|
@@ -344,9 +521,6 @@ export declare function BlockComponentsAbsoluteUrl(prefix: string): z.ZodObject<
|
|
|
344
521
|
}>;
|
|
345
522
|
}, "strip", z.ZodTypeAny, {
|
|
346
523
|
workflow: {
|
|
347
|
-
type: string;
|
|
348
|
-
main: any;
|
|
349
|
-
} | {
|
|
350
524
|
type: "workflow-v1";
|
|
351
525
|
main: {
|
|
352
526
|
type: "explicit-base64";
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"block_components.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAErC,wBAAgB,QAAQ,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO
|
|
1
|
+
{"version":3,"file":"block_components.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_components.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,MAAM,MAAM,mBAAmB,GAAG,EAAE,CAAC;AAErC,wBAAgB,UAAU,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO;;;;;;;;;;;;;;;YAKlF;AAED,wBAAgB,QAAQ,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAC,UAAU,EAAE,WAAW,EAAE,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAYhF;AAED,wBAAgB,eAAe,CAC7B,KAAK,CAAC,UAAU,SAAS,CAAC,CAAC,UAAU,EACrC,KAAK,CAAC,EAAE,SAAS,CAAC,CAAC,UAAU,EAC7B,UAAU,EAAE,UAAU,EAAE,EAAE,EAAE,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAM/B;AAED,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA0C,CAAC;AACrF,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAE1F,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKxD;AACD,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,OAAO,0BAA0B,CAAC,CAAC,CAAC"}
|
|
@@ -4,10 +4,19 @@ import { z, ZodTypeAny } from 'zod';
|
|
|
4
4
|
* strings are converted to explicit content type. */
|
|
5
5
|
export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
6
6
|
components: z.ZodObject<{
|
|
7
|
-
workflow: z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
8
|
-
type:
|
|
9
|
-
main:
|
|
10
|
-
}, string>, z.
|
|
7
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<z.ZodString, {
|
|
8
|
+
type: "workflow-v1";
|
|
9
|
+
main: string;
|
|
10
|
+
}, string>, z.ZodObject<{
|
|
11
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
12
|
+
main: z.ZodString;
|
|
13
|
+
}, "strip", z.ZodTypeAny, {
|
|
14
|
+
type: "workflow-v1";
|
|
15
|
+
main: string;
|
|
16
|
+
}, {
|
|
17
|
+
type: "workflow-v1";
|
|
18
|
+
main: string;
|
|
19
|
+
}>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
11
20
|
type: z.ZodLiteral<"workflow-v1">;
|
|
12
21
|
main: z.ZodString;
|
|
13
22
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -21,9 +30,6 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
21
30
|
ui: z.ZodString;
|
|
22
31
|
}, "strip", z.ZodTypeAny, {
|
|
23
32
|
workflow: {
|
|
24
|
-
type: string;
|
|
25
|
-
main: any;
|
|
26
|
-
} | {
|
|
27
33
|
type: "workflow-v1";
|
|
28
34
|
main: string;
|
|
29
35
|
};
|
|
@@ -74,6 +80,40 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
74
80
|
type: "absolute-file";
|
|
75
81
|
file: string;
|
|
76
82
|
}>]>]>>;
|
|
83
|
+
changelog: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
84
|
+
type: "explicit-string";
|
|
85
|
+
content: string;
|
|
86
|
+
} | {
|
|
87
|
+
type: "relative";
|
|
88
|
+
path: string;
|
|
89
|
+
}, string>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
90
|
+
type: z.ZodLiteral<"explicit-string">;
|
|
91
|
+
content: z.ZodString;
|
|
92
|
+
}, "strict", z.ZodTypeAny, {
|
|
93
|
+
type: "explicit-string";
|
|
94
|
+
content: string;
|
|
95
|
+
}, {
|
|
96
|
+
type: "explicit-string";
|
|
97
|
+
content: string;
|
|
98
|
+
}>, z.ZodObject<{
|
|
99
|
+
type: z.ZodLiteral<"relative">;
|
|
100
|
+
path: z.ZodString;
|
|
101
|
+
}, "strict", z.ZodTypeAny, {
|
|
102
|
+
type: "relative";
|
|
103
|
+
path: string;
|
|
104
|
+
}, {
|
|
105
|
+
type: "relative";
|
|
106
|
+
path: string;
|
|
107
|
+
}>, z.ZodObject<{
|
|
108
|
+
type: z.ZodLiteral<"absolute-file">;
|
|
109
|
+
file: z.ZodString;
|
|
110
|
+
}, "strict", z.ZodTypeAny, {
|
|
111
|
+
type: "absolute-file";
|
|
112
|
+
file: string;
|
|
113
|
+
}, {
|
|
114
|
+
type: "absolute-file";
|
|
115
|
+
file: string;
|
|
116
|
+
}>]>]>>;
|
|
77
117
|
logo: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
78
118
|
type: "explicit-base64";
|
|
79
119
|
content: string;
|
|
@@ -215,6 +255,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
215
255
|
type: "absolute-file";
|
|
216
256
|
file: string;
|
|
217
257
|
} | undefined;
|
|
258
|
+
changelog?: {
|
|
259
|
+
type: "explicit-string";
|
|
260
|
+
content: string;
|
|
261
|
+
} | {
|
|
262
|
+
type: "relative";
|
|
263
|
+
path: string;
|
|
264
|
+
} | {
|
|
265
|
+
type: "absolute-file";
|
|
266
|
+
file: string;
|
|
267
|
+
} | undefined;
|
|
218
268
|
logo?: {
|
|
219
269
|
type: "explicit-base64";
|
|
220
270
|
content: string;
|
|
@@ -258,6 +308,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
258
308
|
type: "absolute-file";
|
|
259
309
|
file: string;
|
|
260
310
|
} | undefined;
|
|
311
|
+
changelog?: string | {
|
|
312
|
+
type: "explicit-string";
|
|
313
|
+
content: string;
|
|
314
|
+
} | {
|
|
315
|
+
type: "relative";
|
|
316
|
+
path: string;
|
|
317
|
+
} | {
|
|
318
|
+
type: "absolute-file";
|
|
319
|
+
file: string;
|
|
320
|
+
} | undefined;
|
|
261
321
|
logo?: string | {
|
|
262
322
|
type: "explicit-base64";
|
|
263
323
|
content: string;
|
|
@@ -276,9 +336,6 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
276
336
|
}, "strip", z.ZodTypeAny, {
|
|
277
337
|
components: {
|
|
278
338
|
workflow: {
|
|
279
|
-
type: string;
|
|
280
|
-
main: any;
|
|
281
|
-
} | {
|
|
282
339
|
type: "workflow-v1";
|
|
283
340
|
main: string;
|
|
284
341
|
};
|
|
@@ -314,6 +371,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
314
371
|
type: "absolute-file";
|
|
315
372
|
file: string;
|
|
316
373
|
} | undefined;
|
|
374
|
+
changelog?: {
|
|
375
|
+
type: "explicit-string";
|
|
376
|
+
content: string;
|
|
377
|
+
} | {
|
|
378
|
+
type: "relative";
|
|
379
|
+
path: string;
|
|
380
|
+
} | {
|
|
381
|
+
type: "absolute-file";
|
|
382
|
+
file: string;
|
|
383
|
+
} | undefined;
|
|
317
384
|
logo?: {
|
|
318
385
|
type: "explicit-base64";
|
|
319
386
|
content: string;
|
|
@@ -367,6 +434,16 @@ export declare const BlockPackDescriptionFromPackageJsonRaw: z.ZodObject<{
|
|
|
367
434
|
type: "absolute-file";
|
|
368
435
|
file: string;
|
|
369
436
|
} | undefined;
|
|
437
|
+
changelog?: string | {
|
|
438
|
+
type: "explicit-string";
|
|
439
|
+
content: string;
|
|
440
|
+
} | {
|
|
441
|
+
type: "relative";
|
|
442
|
+
path: string;
|
|
443
|
+
} | {
|
|
444
|
+
type: "absolute-file";
|
|
445
|
+
file: string;
|
|
446
|
+
} | undefined;
|
|
370
447
|
logo?: string | {
|
|
371
448
|
type: "explicit-base64";
|
|
372
449
|
content: string;
|
|
@@ -479,10 +556,19 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
479
556
|
version: string;
|
|
480
557
|
}>;
|
|
481
558
|
components: z.ZodObject<{
|
|
482
|
-
workflow: z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
483
|
-
type:
|
|
484
|
-
main:
|
|
485
|
-
}, string>, z.
|
|
559
|
+
workflow: z.ZodUnion<[z.ZodPipeline<z.ZodEffects<z.ZodString, {
|
|
560
|
+
type: "workflow-v1";
|
|
561
|
+
main: string;
|
|
562
|
+
}, string>, z.ZodObject<{
|
|
563
|
+
type: z.ZodLiteral<"workflow-v1">;
|
|
564
|
+
main: z.ZodString;
|
|
565
|
+
}, "strip", z.ZodTypeAny, {
|
|
566
|
+
type: "workflow-v1";
|
|
567
|
+
main: string;
|
|
568
|
+
}, {
|
|
569
|
+
type: "workflow-v1";
|
|
570
|
+
main: string;
|
|
571
|
+
}>>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
486
572
|
type: z.ZodLiteral<"workflow-v1">;
|
|
487
573
|
main: z.ZodString;
|
|
488
574
|
}, "strip", z.ZodTypeAny, {
|
|
@@ -496,9 +582,6 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
496
582
|
ui: z.ZodString;
|
|
497
583
|
}, "strip", z.ZodTypeAny, {
|
|
498
584
|
workflow: {
|
|
499
|
-
type: string;
|
|
500
|
-
main: any;
|
|
501
|
-
} | {
|
|
502
585
|
type: "workflow-v1";
|
|
503
586
|
main: string;
|
|
504
587
|
};
|
|
@@ -549,6 +632,40 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
549
632
|
type: "absolute-file";
|
|
550
633
|
file: string;
|
|
551
634
|
}>]>]>>;
|
|
635
|
+
changelog: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
636
|
+
type: "explicit-string";
|
|
637
|
+
content: string;
|
|
638
|
+
} | {
|
|
639
|
+
type: "relative";
|
|
640
|
+
path: string;
|
|
641
|
+
}, string>, z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
|
|
642
|
+
type: z.ZodLiteral<"explicit-string">;
|
|
643
|
+
content: z.ZodString;
|
|
644
|
+
}, "strict", z.ZodTypeAny, {
|
|
645
|
+
type: "explicit-string";
|
|
646
|
+
content: string;
|
|
647
|
+
}, {
|
|
648
|
+
type: "explicit-string";
|
|
649
|
+
content: string;
|
|
650
|
+
}>, z.ZodObject<{
|
|
651
|
+
type: z.ZodLiteral<"relative">;
|
|
652
|
+
path: z.ZodString;
|
|
653
|
+
}, "strict", z.ZodTypeAny, {
|
|
654
|
+
type: "relative";
|
|
655
|
+
path: string;
|
|
656
|
+
}, {
|
|
657
|
+
type: "relative";
|
|
658
|
+
path: string;
|
|
659
|
+
}>, z.ZodObject<{
|
|
660
|
+
type: z.ZodLiteral<"absolute-file">;
|
|
661
|
+
file: z.ZodString;
|
|
662
|
+
}, "strict", z.ZodTypeAny, {
|
|
663
|
+
type: "absolute-file";
|
|
664
|
+
file: string;
|
|
665
|
+
}, {
|
|
666
|
+
type: "absolute-file";
|
|
667
|
+
file: string;
|
|
668
|
+
}>]>]>>;
|
|
552
669
|
logo: z.ZodOptional<z.ZodUnion<[z.ZodEffects<z.ZodString, {
|
|
553
670
|
type: "explicit-base64";
|
|
554
671
|
content: string;
|
|
@@ -690,6 +807,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
690
807
|
type: "absolute-file";
|
|
691
808
|
file: string;
|
|
692
809
|
} | undefined;
|
|
810
|
+
changelog?: {
|
|
811
|
+
type: "explicit-string";
|
|
812
|
+
content: string;
|
|
813
|
+
} | {
|
|
814
|
+
type: "relative";
|
|
815
|
+
path: string;
|
|
816
|
+
} | {
|
|
817
|
+
type: "absolute-file";
|
|
818
|
+
file: string;
|
|
819
|
+
} | undefined;
|
|
693
820
|
logo?: {
|
|
694
821
|
type: "explicit-base64";
|
|
695
822
|
content: string;
|
|
@@ -733,6 +860,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
733
860
|
type: "absolute-file";
|
|
734
861
|
file: string;
|
|
735
862
|
} | undefined;
|
|
863
|
+
changelog?: string | {
|
|
864
|
+
type: "explicit-string";
|
|
865
|
+
content: string;
|
|
866
|
+
} | {
|
|
867
|
+
type: "relative";
|
|
868
|
+
path: string;
|
|
869
|
+
} | {
|
|
870
|
+
type: "absolute-file";
|
|
871
|
+
file: string;
|
|
872
|
+
} | undefined;
|
|
736
873
|
logo?: string | {
|
|
737
874
|
type: "explicit-base64";
|
|
738
875
|
content: string;
|
|
@@ -751,9 +888,6 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
751
888
|
}, "strip", z.ZodTypeAny, {
|
|
752
889
|
components: {
|
|
753
890
|
workflow: {
|
|
754
|
-
type: string;
|
|
755
|
-
main: any;
|
|
756
|
-
} | {
|
|
757
891
|
type: "workflow-v1";
|
|
758
892
|
main: string;
|
|
759
893
|
};
|
|
@@ -789,6 +923,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
789
923
|
type: "absolute-file";
|
|
790
924
|
file: string;
|
|
791
925
|
} | undefined;
|
|
926
|
+
changelog?: {
|
|
927
|
+
type: "explicit-string";
|
|
928
|
+
content: string;
|
|
929
|
+
} | {
|
|
930
|
+
type: "relative";
|
|
931
|
+
path: string;
|
|
932
|
+
} | {
|
|
933
|
+
type: "absolute-file";
|
|
934
|
+
file: string;
|
|
935
|
+
} | undefined;
|
|
792
936
|
logo?: {
|
|
793
937
|
type: "explicit-base64";
|
|
794
938
|
content: string;
|
|
@@ -847,6 +991,16 @@ export declare const BlockPackDescriptionRaw: z.ZodObject<{
|
|
|
847
991
|
type: "absolute-file";
|
|
848
992
|
file: string;
|
|
849
993
|
} | undefined;
|
|
994
|
+
changelog?: string | {
|
|
995
|
+
type: "explicit-string";
|
|
996
|
+
content: string;
|
|
997
|
+
} | {
|
|
998
|
+
type: "relative";
|
|
999
|
+
path: string;
|
|
1000
|
+
} | {
|
|
1001
|
+
type: "absolute-file";
|
|
1002
|
+
file: string;
|
|
1003
|
+
} | undefined;
|
|
850
1004
|
logo?: string | {
|
|
851
1005
|
type: "explicit-base64";
|
|
852
1006
|
content: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"block_description.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAKpC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC
|
|
1
|
+
{"version":3,"file":"block_description.d.ts","sourceRoot":"","sources":["../../src/block_meta/block_description.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,UAAU,EAAE,MAAM,KAAK,CAAC;AAKpC;;qDAEqD;AACrD,eAAO,MAAM,sCAAsC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGjD,CAAC;AAEH,wBAAgB,gCAAgC,CAC9C,UAAU,SAAS,UAAU,EAC7B,IAAI,SAAS,UAAU,EACvB,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAMnC;AAED,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAGnC,CAAC;AACF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
|