pareto 0.69.0 → 0.70.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/auto.dist/data/boekhouding.data.d.ts +1 -1
- package/auto.dist/data/boekhouding.data.js +8 -8
- package/auto.dist/public/modules/main/implementations/temp$_compile$_boekhouding.alg.js +27 -29
- package/auto.pareto/auto.dependencies/index.ts +1 -1
- package/auto.pareto/auto.dependencies/pareto-pure/$.data.ts +8 -4
- package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_constrained.data.ts +2955 -0
- package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_resolved.data.ts +2955 -0
- package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_unconstrained.data.ts +2956 -0
- package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_unresolved.data.ts +2956 -0
- package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_possibly_constrained.data.ts +1170 -0
- package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_unconstrained.data.ts +1035 -0
- package/auto.pareto/modules/cosmos_type_system_2_typescript_intermediate/api.data.ts +1 -1
- package/package.json +3 -3
package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_unconstrained.data.ts
ADDED
|
@@ -0,0 +1,1035 @@
|
|
|
1
|
+
import * as pd from 'pareto-core-data'
|
|
2
|
+
|
|
3
|
+
import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
|
|
4
|
+
|
|
5
|
+
const d = pd.d
|
|
6
|
+
const a = pd.a
|
|
7
|
+
|
|
8
|
+
export const $: g_cosmos.D.Data__Glossary = {
|
|
9
|
+
'glossary parameters': d({
|
|
10
|
+
"Annotation": null,
|
|
11
|
+
}),
|
|
12
|
+
'imports': d({
|
|
13
|
+
}),
|
|
14
|
+
'root': {
|
|
15
|
+
'data types': d({
|
|
16
|
+
"Atom": {
|
|
17
|
+
'parameters': d({
|
|
18
|
+
}),
|
|
19
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
20
|
+
"type": ['group', d<g_cosmos.D.Data__Type>({
|
|
21
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
22
|
+
"key": ['text', null],
|
|
23
|
+
})],
|
|
24
|
+
})],
|
|
25
|
+
},
|
|
26
|
+
"Dictionary Constraints": {
|
|
27
|
+
'parameters': d({
|
|
28
|
+
}),
|
|
29
|
+
'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
|
|
30
|
+
"type": ['component', ['type', {
|
|
31
|
+
'context': ['local', null],
|
|
32
|
+
'tailXX': a([
|
|
33
|
+
]),
|
|
34
|
+
'type arguments': d({
|
|
35
|
+
}),
|
|
36
|
+
'typeXX': "Type Selection",
|
|
37
|
+
}]],
|
|
38
|
+
})]],
|
|
39
|
+
},
|
|
40
|
+
"Global Type": {
|
|
41
|
+
'parameters': d({
|
|
42
|
+
}),
|
|
43
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
44
|
+
"type": ['component', ['type', {
|
|
45
|
+
'context': ['local', null],
|
|
46
|
+
'tailXX': a([
|
|
47
|
+
]),
|
|
48
|
+
'type arguments': d({
|
|
49
|
+
}),
|
|
50
|
+
'typeXX': "Type",
|
|
51
|
+
}]],
|
|
52
|
+
})],
|
|
53
|
+
},
|
|
54
|
+
"Global Type Selection": {
|
|
55
|
+
'parameters': d({
|
|
56
|
+
}),
|
|
57
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
58
|
+
"import": ['optional', ['group', d<g_cosmos.D.Data__Type>({
|
|
59
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
60
|
+
"key": ['text', null],
|
|
61
|
+
})]],
|
|
62
|
+
"type": ['group', d<g_cosmos.D.Data__Type>({
|
|
63
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
64
|
+
"key": ['text', null],
|
|
65
|
+
})],
|
|
66
|
+
})],
|
|
67
|
+
},
|
|
68
|
+
"Imports": {
|
|
69
|
+
'parameters': d({
|
|
70
|
+
}),
|
|
71
|
+
'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
|
|
72
|
+
})]],
|
|
73
|
+
},
|
|
74
|
+
"Labels": {
|
|
75
|
+
'parameters': d({
|
|
76
|
+
}),
|
|
77
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
78
|
+
"atom types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
|
|
79
|
+
})]],
|
|
80
|
+
})],
|
|
81
|
+
},
|
|
82
|
+
"Model": {
|
|
83
|
+
'parameters': d({
|
|
84
|
+
}),
|
|
85
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
86
|
+
"root": ['group', d<g_cosmos.D.Data__Type>({
|
|
87
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
88
|
+
"key": ['text', null],
|
|
89
|
+
})],
|
|
90
|
+
"type library": ['component', ['type', {
|
|
91
|
+
'context': ['local', null],
|
|
92
|
+
'tailXX': a([
|
|
93
|
+
]),
|
|
94
|
+
'type arguments': d({
|
|
95
|
+
}),
|
|
96
|
+
'typeXX': "Type Library",
|
|
97
|
+
}]],
|
|
98
|
+
})],
|
|
99
|
+
},
|
|
100
|
+
"Properties": {
|
|
101
|
+
'parameters': d({
|
|
102
|
+
}),
|
|
103
|
+
'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
|
|
104
|
+
"type": ['component', ['type', {
|
|
105
|
+
'context': ['local', null],
|
|
106
|
+
'tailXX': a([
|
|
107
|
+
]),
|
|
108
|
+
'type arguments': d({
|
|
109
|
+
}),
|
|
110
|
+
'typeXX': "Type",
|
|
111
|
+
}]],
|
|
112
|
+
})]],
|
|
113
|
+
},
|
|
114
|
+
"State Constraints": {
|
|
115
|
+
'parameters': d({
|
|
116
|
+
}),
|
|
117
|
+
'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
|
|
118
|
+
"state": ['group', d<g_cosmos.D.Data__Type>({
|
|
119
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
120
|
+
"key": ['text', null],
|
|
121
|
+
})],
|
|
122
|
+
"type": ['component', ['type', {
|
|
123
|
+
'context': ['local', null],
|
|
124
|
+
'tailXX': a([
|
|
125
|
+
]),
|
|
126
|
+
'type arguments': d({
|
|
127
|
+
}),
|
|
128
|
+
'typeXX': "Type Selection",
|
|
129
|
+
}]],
|
|
130
|
+
})]],
|
|
131
|
+
},
|
|
132
|
+
"Type": {
|
|
133
|
+
'parameters': d({
|
|
134
|
+
}),
|
|
135
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
136
|
+
"type": ['state group', d({
|
|
137
|
+
"component": ['group', d<g_cosmos.D.Data__Type>({
|
|
138
|
+
"context": ['state group', d({
|
|
139
|
+
"import": ['group', d<g_cosmos.D.Data__Type>({
|
|
140
|
+
"library": ['group', d<g_cosmos.D.Data__Type>({
|
|
141
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
142
|
+
"key": ['text', null],
|
|
143
|
+
})],
|
|
144
|
+
"type": ['group', d<g_cosmos.D.Data__Type>({
|
|
145
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
146
|
+
"key": ['text', null],
|
|
147
|
+
})],
|
|
148
|
+
})],
|
|
149
|
+
"sibling": ['group', d<g_cosmos.D.Data__Type>({
|
|
150
|
+
"type": ['group', d<g_cosmos.D.Data__Type>({
|
|
151
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
152
|
+
"key": ['text', null],
|
|
153
|
+
})],
|
|
154
|
+
})],
|
|
155
|
+
})],
|
|
156
|
+
})],
|
|
157
|
+
"dictionary": ['group', d<g_cosmos.D.Data__Type>({
|
|
158
|
+
"constraints": ['optional', ['component', ['type', {
|
|
159
|
+
'context': ['local', null],
|
|
160
|
+
'tailXX': a([
|
|
161
|
+
]),
|
|
162
|
+
'type arguments': d({
|
|
163
|
+
}),
|
|
164
|
+
'typeXX': "Dictionary Constraints",
|
|
165
|
+
}]]],
|
|
166
|
+
"key": ['component', ['type', {
|
|
167
|
+
'context': ['local', null],
|
|
168
|
+
'tailXX': a([
|
|
169
|
+
]),
|
|
170
|
+
'type arguments': d({
|
|
171
|
+
}),
|
|
172
|
+
'typeXX': "Atom",
|
|
173
|
+
}]],
|
|
174
|
+
"type": ['component', ['type', {
|
|
175
|
+
'context': ['local', null],
|
|
176
|
+
'tailXX': a([
|
|
177
|
+
]),
|
|
178
|
+
'type arguments': d({
|
|
179
|
+
}),
|
|
180
|
+
'typeXX': "Type",
|
|
181
|
+
}]],
|
|
182
|
+
})],
|
|
183
|
+
"group": ['group', d<g_cosmos.D.Data__Type>({
|
|
184
|
+
"properties": ['component', ['type', {
|
|
185
|
+
'context': ['local', null],
|
|
186
|
+
'tailXX': a([
|
|
187
|
+
]),
|
|
188
|
+
'type arguments': d({
|
|
189
|
+
}),
|
|
190
|
+
'typeXX': "Properties",
|
|
191
|
+
}]],
|
|
192
|
+
})],
|
|
193
|
+
"list": ['group', d<g_cosmos.D.Data__Type>({
|
|
194
|
+
"type": ['component', ['type', {
|
|
195
|
+
'context': ['local', null],
|
|
196
|
+
'tailXX': a([
|
|
197
|
+
]),
|
|
198
|
+
'type arguments': d({
|
|
199
|
+
}),
|
|
200
|
+
'typeXX': "Type",
|
|
201
|
+
}]],
|
|
202
|
+
})],
|
|
203
|
+
"nothing": ['group', d<g_cosmos.D.Data__Type>({
|
|
204
|
+
})],
|
|
205
|
+
"optional": ['group', d<g_cosmos.D.Data__Type>({
|
|
206
|
+
"type": ['component', ['type', {
|
|
207
|
+
'context': ['local', null],
|
|
208
|
+
'tailXX': a([
|
|
209
|
+
]),
|
|
210
|
+
'type arguments': d({
|
|
211
|
+
}),
|
|
212
|
+
'typeXX': "Type",
|
|
213
|
+
}]],
|
|
214
|
+
})],
|
|
215
|
+
"state group": ['group', d<g_cosmos.D.Data__Type>({
|
|
216
|
+
"states": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
|
|
217
|
+
"constraints": ['optional', ['component', ['type', {
|
|
218
|
+
'context': ['local', null],
|
|
219
|
+
'tailXX': a([
|
|
220
|
+
]),
|
|
221
|
+
'type arguments': d({
|
|
222
|
+
}),
|
|
223
|
+
'typeXX': "State Constraints",
|
|
224
|
+
}]]],
|
|
225
|
+
"type": ['component', ['type', {
|
|
226
|
+
'context': ['local', null],
|
|
227
|
+
'tailXX': a([
|
|
228
|
+
]),
|
|
229
|
+
'type arguments': d({
|
|
230
|
+
}),
|
|
231
|
+
'typeXX': "Type",
|
|
232
|
+
}]],
|
|
233
|
+
})]],
|
|
234
|
+
})],
|
|
235
|
+
"terminal": ['group', d<g_cosmos.D.Data__Type>({
|
|
236
|
+
"constraint": ['optional', ['group', d<g_cosmos.D.Data__Type>({
|
|
237
|
+
"type": ['component', ['type', {
|
|
238
|
+
'context': ['local', null],
|
|
239
|
+
'tailXX': a([
|
|
240
|
+
]),
|
|
241
|
+
'type arguments': d({
|
|
242
|
+
}),
|
|
243
|
+
'typeXX': "Type Selection",
|
|
244
|
+
}]],
|
|
245
|
+
})]],
|
|
246
|
+
"terminal": ['component', ['type', {
|
|
247
|
+
'context': ['local', null],
|
|
248
|
+
'tailXX': a([
|
|
249
|
+
]),
|
|
250
|
+
'type arguments': d({
|
|
251
|
+
}),
|
|
252
|
+
'typeXX': "Atom",
|
|
253
|
+
}]],
|
|
254
|
+
})],
|
|
255
|
+
})],
|
|
256
|
+
})],
|
|
257
|
+
},
|
|
258
|
+
"Type Library": {
|
|
259
|
+
'parameters': d({
|
|
260
|
+
}),
|
|
261
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
262
|
+
"global types": ['dictionary', ['component', ['type', {
|
|
263
|
+
'context': ['local', null],
|
|
264
|
+
'tailXX': a([
|
|
265
|
+
]),
|
|
266
|
+
'type arguments': d({
|
|
267
|
+
}),
|
|
268
|
+
'typeXX': "Global Type",
|
|
269
|
+
}]]],
|
|
270
|
+
"imports": ['component', ['type', {
|
|
271
|
+
'context': ['local', null],
|
|
272
|
+
'tailXX': a([
|
|
273
|
+
]),
|
|
274
|
+
'type arguments': d({
|
|
275
|
+
}),
|
|
276
|
+
'typeXX': "Imports",
|
|
277
|
+
}]],
|
|
278
|
+
"labels": ['component', ['type', {
|
|
279
|
+
'context': ['local', null],
|
|
280
|
+
'tailXX': a([
|
|
281
|
+
]),
|
|
282
|
+
'type arguments': d({
|
|
283
|
+
}),
|
|
284
|
+
'typeXX': "Labels",
|
|
285
|
+
}]],
|
|
286
|
+
})],
|
|
287
|
+
},
|
|
288
|
+
"Type Selection": {
|
|
289
|
+
'parameters': d({
|
|
290
|
+
}),
|
|
291
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
292
|
+
"global type": ['component', ['type', {
|
|
293
|
+
'context': ['local', null],
|
|
294
|
+
'tailXX': a([
|
|
295
|
+
]),
|
|
296
|
+
'type arguments': d({
|
|
297
|
+
}),
|
|
298
|
+
'typeXX': "Global Type Selection",
|
|
299
|
+
}]],
|
|
300
|
+
"tail": ['optional', ['component', ['type', {
|
|
301
|
+
'context': ['local', null],
|
|
302
|
+
'tailXX': a([
|
|
303
|
+
]),
|
|
304
|
+
'type arguments': d({
|
|
305
|
+
}),
|
|
306
|
+
'typeXX': "Type Selection Tail",
|
|
307
|
+
}]]],
|
|
308
|
+
})],
|
|
309
|
+
},
|
|
310
|
+
"Type Selection Tail": {
|
|
311
|
+
'parameters': d({
|
|
312
|
+
}),
|
|
313
|
+
'type': ['group', d<g_cosmos.D.Data__Type>({
|
|
314
|
+
"step type": ['state group', d({
|
|
315
|
+
"dictionary": ['group', d<g_cosmos.D.Data__Type>({
|
|
316
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
317
|
+
"content": ['group', d<g_cosmos.D.Data__Type>({
|
|
318
|
+
})],
|
|
319
|
+
})],
|
|
320
|
+
"group": ['group', d<g_cosmos.D.Data__Type>({
|
|
321
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
322
|
+
"content": ['group', d<g_cosmos.D.Data__Type>({
|
|
323
|
+
"property": ['group', d<g_cosmos.D.Data__Type>({
|
|
324
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
325
|
+
"key": ['text', null],
|
|
326
|
+
})],
|
|
327
|
+
})],
|
|
328
|
+
})],
|
|
329
|
+
"list": ['group', d<g_cosmos.D.Data__Type>({
|
|
330
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
331
|
+
"content": ['group', d<g_cosmos.D.Data__Type>({
|
|
332
|
+
})],
|
|
333
|
+
})],
|
|
334
|
+
"optional": ['group', d<g_cosmos.D.Data__Type>({
|
|
335
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
336
|
+
"content": ['group', d<g_cosmos.D.Data__Type>({
|
|
337
|
+
})],
|
|
338
|
+
})],
|
|
339
|
+
"state group": ['group', d<g_cosmos.D.Data__Type>({
|
|
340
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
341
|
+
"content": ['group', d<g_cosmos.D.Data__Type>({
|
|
342
|
+
"state": ['group', d<g_cosmos.D.Data__Type>({
|
|
343
|
+
"annotation": ['component', ['glossary parameterXX', "Annotation"]],
|
|
344
|
+
"key": ['text', null],
|
|
345
|
+
})],
|
|
346
|
+
})],
|
|
347
|
+
})],
|
|
348
|
+
})],
|
|
349
|
+
"tail": ['optional', ['component', ['type', {
|
|
350
|
+
'context': ['local', null],
|
|
351
|
+
'tailXX': a([
|
|
352
|
+
]),
|
|
353
|
+
'type arguments': d({
|
|
354
|
+
}),
|
|
355
|
+
'typeXX': "Type Selection Tail",
|
|
356
|
+
}]]],
|
|
357
|
+
})],
|
|
358
|
+
},
|
|
359
|
+
}),
|
|
360
|
+
'namespaces': d({
|
|
361
|
+
"Atom": {
|
|
362
|
+
'data types': d({
|
|
363
|
+
}),
|
|
364
|
+
'namespaces': d({
|
|
365
|
+
"G": {
|
|
366
|
+
'data types': d({
|
|
367
|
+
}),
|
|
368
|
+
'namespaces': d({
|
|
369
|
+
"type": {
|
|
370
|
+
'data types': d({
|
|
371
|
+
}),
|
|
372
|
+
'namespaces': d({
|
|
373
|
+
}),
|
|
374
|
+
},
|
|
375
|
+
}),
|
|
376
|
+
},
|
|
377
|
+
}),
|
|
378
|
+
},
|
|
379
|
+
"Dictionary Constraints": {
|
|
380
|
+
'data types': d({
|
|
381
|
+
}),
|
|
382
|
+
'namespaces': d({
|
|
383
|
+
"DX": {
|
|
384
|
+
'data types': d({
|
|
385
|
+
}),
|
|
386
|
+
'namespaces': d({
|
|
387
|
+
"G": {
|
|
388
|
+
'data types': d({
|
|
389
|
+
}),
|
|
390
|
+
'namespaces': d({
|
|
391
|
+
"type": {
|
|
392
|
+
'data types': d({
|
|
393
|
+
}),
|
|
394
|
+
'namespaces': d({
|
|
395
|
+
}),
|
|
396
|
+
},
|
|
397
|
+
}),
|
|
398
|
+
},
|
|
399
|
+
}),
|
|
400
|
+
},
|
|
401
|
+
}),
|
|
402
|
+
},
|
|
403
|
+
"Global Type": {
|
|
404
|
+
'data types': d({
|
|
405
|
+
}),
|
|
406
|
+
'namespaces': d({
|
|
407
|
+
"G": {
|
|
408
|
+
'data types': d({
|
|
409
|
+
}),
|
|
410
|
+
'namespaces': d({
|
|
411
|
+
"type": {
|
|
412
|
+
'data types': d({
|
|
413
|
+
}),
|
|
414
|
+
'namespaces': d({
|
|
415
|
+
}),
|
|
416
|
+
},
|
|
417
|
+
}),
|
|
418
|
+
},
|
|
419
|
+
}),
|
|
420
|
+
},
|
|
421
|
+
"Global Type Selection": {
|
|
422
|
+
'data types': d({
|
|
423
|
+
}),
|
|
424
|
+
'namespaces': d({
|
|
425
|
+
"G": {
|
|
426
|
+
'data types': d({
|
|
427
|
+
}),
|
|
428
|
+
'namespaces': d({
|
|
429
|
+
"import": {
|
|
430
|
+
'data types': d({
|
|
431
|
+
}),
|
|
432
|
+
'namespaces': d({
|
|
433
|
+
"O": {
|
|
434
|
+
'data types': d({
|
|
435
|
+
}),
|
|
436
|
+
'namespaces': d({
|
|
437
|
+
}),
|
|
438
|
+
},
|
|
439
|
+
}),
|
|
440
|
+
},
|
|
441
|
+
"type": {
|
|
442
|
+
'data types': d({
|
|
443
|
+
}),
|
|
444
|
+
'namespaces': d({
|
|
445
|
+
}),
|
|
446
|
+
},
|
|
447
|
+
}),
|
|
448
|
+
},
|
|
449
|
+
}),
|
|
450
|
+
},
|
|
451
|
+
"Imports": {
|
|
452
|
+
'data types': d({
|
|
453
|
+
}),
|
|
454
|
+
'namespaces': d({
|
|
455
|
+
"DX": {
|
|
456
|
+
'data types': d({
|
|
457
|
+
}),
|
|
458
|
+
'namespaces': d({
|
|
459
|
+
"G": {
|
|
460
|
+
'data types': d({
|
|
461
|
+
}),
|
|
462
|
+
'namespaces': d({
|
|
463
|
+
}),
|
|
464
|
+
},
|
|
465
|
+
}),
|
|
466
|
+
},
|
|
467
|
+
}),
|
|
468
|
+
},
|
|
469
|
+
"Labels": {
|
|
470
|
+
'data types': d({
|
|
471
|
+
}),
|
|
472
|
+
'namespaces': d({
|
|
473
|
+
"G": {
|
|
474
|
+
'data types': d({
|
|
475
|
+
}),
|
|
476
|
+
'namespaces': d({
|
|
477
|
+
"atom types": {
|
|
478
|
+
'data types': d({
|
|
479
|
+
}),
|
|
480
|
+
'namespaces': d({
|
|
481
|
+
"DX": {
|
|
482
|
+
'data types': d({
|
|
483
|
+
}),
|
|
484
|
+
'namespaces': d({
|
|
485
|
+
"G": {
|
|
486
|
+
'data types': d({
|
|
487
|
+
}),
|
|
488
|
+
'namespaces': d({
|
|
489
|
+
}),
|
|
490
|
+
},
|
|
491
|
+
}),
|
|
492
|
+
},
|
|
493
|
+
}),
|
|
494
|
+
},
|
|
495
|
+
}),
|
|
496
|
+
},
|
|
497
|
+
}),
|
|
498
|
+
},
|
|
499
|
+
"Model": {
|
|
500
|
+
'data types': d({
|
|
501
|
+
}),
|
|
502
|
+
'namespaces': d({
|
|
503
|
+
"G": {
|
|
504
|
+
'data types': d({
|
|
505
|
+
}),
|
|
506
|
+
'namespaces': d({
|
|
507
|
+
"root": {
|
|
508
|
+
'data types': d({
|
|
509
|
+
}),
|
|
510
|
+
'namespaces': d({
|
|
511
|
+
}),
|
|
512
|
+
},
|
|
513
|
+
"type library": {
|
|
514
|
+
'data types': d({
|
|
515
|
+
}),
|
|
516
|
+
'namespaces': d({
|
|
517
|
+
}),
|
|
518
|
+
},
|
|
519
|
+
}),
|
|
520
|
+
},
|
|
521
|
+
}),
|
|
522
|
+
},
|
|
523
|
+
"Properties": {
|
|
524
|
+
'data types': d({
|
|
525
|
+
}),
|
|
526
|
+
'namespaces': d({
|
|
527
|
+
"DX": {
|
|
528
|
+
'data types': d({
|
|
529
|
+
}),
|
|
530
|
+
'namespaces': d({
|
|
531
|
+
"G": {
|
|
532
|
+
'data types': d({
|
|
533
|
+
}),
|
|
534
|
+
'namespaces': d({
|
|
535
|
+
"type": {
|
|
536
|
+
'data types': d({
|
|
537
|
+
}),
|
|
538
|
+
'namespaces': d({
|
|
539
|
+
}),
|
|
540
|
+
},
|
|
541
|
+
}),
|
|
542
|
+
},
|
|
543
|
+
}),
|
|
544
|
+
},
|
|
545
|
+
}),
|
|
546
|
+
},
|
|
547
|
+
"State Constraints": {
|
|
548
|
+
'data types': d({
|
|
549
|
+
}),
|
|
550
|
+
'namespaces': d({
|
|
551
|
+
"DX": {
|
|
552
|
+
'data types': d({
|
|
553
|
+
}),
|
|
554
|
+
'namespaces': d({
|
|
555
|
+
"G": {
|
|
556
|
+
'data types': d({
|
|
557
|
+
}),
|
|
558
|
+
'namespaces': d({
|
|
559
|
+
"state": {
|
|
560
|
+
'data types': d({
|
|
561
|
+
}),
|
|
562
|
+
'namespaces': d({
|
|
563
|
+
}),
|
|
564
|
+
},
|
|
565
|
+
"type": {
|
|
566
|
+
'data types': d({
|
|
567
|
+
}),
|
|
568
|
+
'namespaces': d({
|
|
569
|
+
}),
|
|
570
|
+
},
|
|
571
|
+
}),
|
|
572
|
+
},
|
|
573
|
+
}),
|
|
574
|
+
},
|
|
575
|
+
}),
|
|
576
|
+
},
|
|
577
|
+
"Type": {
|
|
578
|
+
'data types': d({
|
|
579
|
+
}),
|
|
580
|
+
'namespaces': d({
|
|
581
|
+
"G": {
|
|
582
|
+
'data types': d({
|
|
583
|
+
}),
|
|
584
|
+
'namespaces': d({
|
|
585
|
+
"type": {
|
|
586
|
+
'data types': d({
|
|
587
|
+
}),
|
|
588
|
+
'namespaces': d({
|
|
589
|
+
"TU": {
|
|
590
|
+
'data types': d({
|
|
591
|
+
}),
|
|
592
|
+
'namespaces': d({
|
|
593
|
+
"component": {
|
|
594
|
+
'data types': d({
|
|
595
|
+
}),
|
|
596
|
+
'namespaces': d({
|
|
597
|
+
"G": {
|
|
598
|
+
'data types': d({
|
|
599
|
+
}),
|
|
600
|
+
'namespaces': d({
|
|
601
|
+
"context": {
|
|
602
|
+
'data types': d({
|
|
603
|
+
}),
|
|
604
|
+
'namespaces': d({
|
|
605
|
+
"TU": {
|
|
606
|
+
'data types': d({
|
|
607
|
+
}),
|
|
608
|
+
'namespaces': d({
|
|
609
|
+
"import": {
|
|
610
|
+
'data types': d({
|
|
611
|
+
}),
|
|
612
|
+
'namespaces': d({
|
|
613
|
+
"G": {
|
|
614
|
+
'data types': d({
|
|
615
|
+
}),
|
|
616
|
+
'namespaces': d({
|
|
617
|
+
"library": {
|
|
618
|
+
'data types': d({
|
|
619
|
+
}),
|
|
620
|
+
'namespaces': d({
|
|
621
|
+
}),
|
|
622
|
+
},
|
|
623
|
+
"type": {
|
|
624
|
+
'data types': d({
|
|
625
|
+
}),
|
|
626
|
+
'namespaces': d({
|
|
627
|
+
}),
|
|
628
|
+
},
|
|
629
|
+
}),
|
|
630
|
+
},
|
|
631
|
+
}),
|
|
632
|
+
},
|
|
633
|
+
"sibling": {
|
|
634
|
+
'data types': d({
|
|
635
|
+
}),
|
|
636
|
+
'namespaces': d({
|
|
637
|
+
"G": {
|
|
638
|
+
'data types': d({
|
|
639
|
+
}),
|
|
640
|
+
'namespaces': d({
|
|
641
|
+
"type": {
|
|
642
|
+
'data types': d({
|
|
643
|
+
}),
|
|
644
|
+
'namespaces': d({
|
|
645
|
+
}),
|
|
646
|
+
},
|
|
647
|
+
}),
|
|
648
|
+
},
|
|
649
|
+
}),
|
|
650
|
+
},
|
|
651
|
+
}),
|
|
652
|
+
},
|
|
653
|
+
}),
|
|
654
|
+
},
|
|
655
|
+
}),
|
|
656
|
+
},
|
|
657
|
+
}),
|
|
658
|
+
},
|
|
659
|
+
"dictionary": {
|
|
660
|
+
'data types': d({
|
|
661
|
+
}),
|
|
662
|
+
'namespaces': d({
|
|
663
|
+
"G": {
|
|
664
|
+
'data types': d({
|
|
665
|
+
}),
|
|
666
|
+
'namespaces': d({
|
|
667
|
+
"constraints": {
|
|
668
|
+
'data types': d({
|
|
669
|
+
}),
|
|
670
|
+
'namespaces': d({
|
|
671
|
+
"O": {
|
|
672
|
+
'data types': d({
|
|
673
|
+
}),
|
|
674
|
+
'namespaces': d({
|
|
675
|
+
}),
|
|
676
|
+
},
|
|
677
|
+
}),
|
|
678
|
+
},
|
|
679
|
+
"key": {
|
|
680
|
+
'data types': d({
|
|
681
|
+
}),
|
|
682
|
+
'namespaces': d({
|
|
683
|
+
}),
|
|
684
|
+
},
|
|
685
|
+
"type": {
|
|
686
|
+
'data types': d({
|
|
687
|
+
}),
|
|
688
|
+
'namespaces': d({
|
|
689
|
+
}),
|
|
690
|
+
},
|
|
691
|
+
}),
|
|
692
|
+
},
|
|
693
|
+
}),
|
|
694
|
+
},
|
|
695
|
+
"group": {
|
|
696
|
+
'data types': d({
|
|
697
|
+
}),
|
|
698
|
+
'namespaces': d({
|
|
699
|
+
"G": {
|
|
700
|
+
'data types': d({
|
|
701
|
+
}),
|
|
702
|
+
'namespaces': d({
|
|
703
|
+
"properties": {
|
|
704
|
+
'data types': d({
|
|
705
|
+
}),
|
|
706
|
+
'namespaces': d({
|
|
707
|
+
}),
|
|
708
|
+
},
|
|
709
|
+
}),
|
|
710
|
+
},
|
|
711
|
+
}),
|
|
712
|
+
},
|
|
713
|
+
"list": {
|
|
714
|
+
'data types': d({
|
|
715
|
+
}),
|
|
716
|
+
'namespaces': d({
|
|
717
|
+
"G": {
|
|
718
|
+
'data types': d({
|
|
719
|
+
}),
|
|
720
|
+
'namespaces': d({
|
|
721
|
+
"type": {
|
|
722
|
+
'data types': d({
|
|
723
|
+
}),
|
|
724
|
+
'namespaces': d({
|
|
725
|
+
}),
|
|
726
|
+
},
|
|
727
|
+
}),
|
|
728
|
+
},
|
|
729
|
+
}),
|
|
730
|
+
},
|
|
731
|
+
"nothing": {
|
|
732
|
+
'data types': d({
|
|
733
|
+
}),
|
|
734
|
+
'namespaces': d({
|
|
735
|
+
"G": {
|
|
736
|
+
'data types': d({
|
|
737
|
+
}),
|
|
738
|
+
'namespaces': d({
|
|
739
|
+
}),
|
|
740
|
+
},
|
|
741
|
+
}),
|
|
742
|
+
},
|
|
743
|
+
"optional": {
|
|
744
|
+
'data types': d({
|
|
745
|
+
}),
|
|
746
|
+
'namespaces': d({
|
|
747
|
+
"G": {
|
|
748
|
+
'data types': d({
|
|
749
|
+
}),
|
|
750
|
+
'namespaces': d({
|
|
751
|
+
"type": {
|
|
752
|
+
'data types': d({
|
|
753
|
+
}),
|
|
754
|
+
'namespaces': d({
|
|
755
|
+
}),
|
|
756
|
+
},
|
|
757
|
+
}),
|
|
758
|
+
},
|
|
759
|
+
}),
|
|
760
|
+
},
|
|
761
|
+
"state group": {
|
|
762
|
+
'data types': d({
|
|
763
|
+
}),
|
|
764
|
+
'namespaces': d({
|
|
765
|
+
"G": {
|
|
766
|
+
'data types': d({
|
|
767
|
+
}),
|
|
768
|
+
'namespaces': d({
|
|
769
|
+
"states": {
|
|
770
|
+
'data types': d({
|
|
771
|
+
}),
|
|
772
|
+
'namespaces': d({
|
|
773
|
+
"DX": {
|
|
774
|
+
'data types': d({
|
|
775
|
+
}),
|
|
776
|
+
'namespaces': d({
|
|
777
|
+
"G": {
|
|
778
|
+
'data types': d({
|
|
779
|
+
}),
|
|
780
|
+
'namespaces': d({
|
|
781
|
+
"constraints": {
|
|
782
|
+
'data types': d({
|
|
783
|
+
}),
|
|
784
|
+
'namespaces': d({
|
|
785
|
+
"O": {
|
|
786
|
+
'data types': d({
|
|
787
|
+
}),
|
|
788
|
+
'namespaces': d({
|
|
789
|
+
}),
|
|
790
|
+
},
|
|
791
|
+
}),
|
|
792
|
+
},
|
|
793
|
+
"type": {
|
|
794
|
+
'data types': d({
|
|
795
|
+
}),
|
|
796
|
+
'namespaces': d({
|
|
797
|
+
}),
|
|
798
|
+
},
|
|
799
|
+
}),
|
|
800
|
+
},
|
|
801
|
+
}),
|
|
802
|
+
},
|
|
803
|
+
}),
|
|
804
|
+
},
|
|
805
|
+
}),
|
|
806
|
+
},
|
|
807
|
+
}),
|
|
808
|
+
},
|
|
809
|
+
"terminal": {
|
|
810
|
+
'data types': d({
|
|
811
|
+
}),
|
|
812
|
+
'namespaces': d({
|
|
813
|
+
"G": {
|
|
814
|
+
'data types': d({
|
|
815
|
+
}),
|
|
816
|
+
'namespaces': d({
|
|
817
|
+
"constraint": {
|
|
818
|
+
'data types': d({
|
|
819
|
+
}),
|
|
820
|
+
'namespaces': d({
|
|
821
|
+
"O": {
|
|
822
|
+
'data types': d({
|
|
823
|
+
}),
|
|
824
|
+
'namespaces': d({
|
|
825
|
+
"G": {
|
|
826
|
+
'data types': d({
|
|
827
|
+
}),
|
|
828
|
+
'namespaces': d({
|
|
829
|
+
"type": {
|
|
830
|
+
'data types': d({
|
|
831
|
+
}),
|
|
832
|
+
'namespaces': d({
|
|
833
|
+
}),
|
|
834
|
+
},
|
|
835
|
+
}),
|
|
836
|
+
},
|
|
837
|
+
}),
|
|
838
|
+
},
|
|
839
|
+
}),
|
|
840
|
+
},
|
|
841
|
+
"terminal": {
|
|
842
|
+
'data types': d({
|
|
843
|
+
}),
|
|
844
|
+
'namespaces': d({
|
|
845
|
+
}),
|
|
846
|
+
},
|
|
847
|
+
}),
|
|
848
|
+
},
|
|
849
|
+
}),
|
|
850
|
+
},
|
|
851
|
+
}),
|
|
852
|
+
},
|
|
853
|
+
}),
|
|
854
|
+
},
|
|
855
|
+
}),
|
|
856
|
+
},
|
|
857
|
+
}),
|
|
858
|
+
},
|
|
859
|
+
"Type Library": {
|
|
860
|
+
'data types': d({
|
|
861
|
+
}),
|
|
862
|
+
'namespaces': d({
|
|
863
|
+
"G": {
|
|
864
|
+
'data types': d({
|
|
865
|
+
}),
|
|
866
|
+
'namespaces': d({
|
|
867
|
+
"global types": {
|
|
868
|
+
'data types': d({
|
|
869
|
+
}),
|
|
870
|
+
'namespaces': d({
|
|
871
|
+
"DX": {
|
|
872
|
+
'data types': d({
|
|
873
|
+
}),
|
|
874
|
+
'namespaces': d({
|
|
875
|
+
}),
|
|
876
|
+
},
|
|
877
|
+
}),
|
|
878
|
+
},
|
|
879
|
+
"imports": {
|
|
880
|
+
'data types': d({
|
|
881
|
+
}),
|
|
882
|
+
'namespaces': d({
|
|
883
|
+
}),
|
|
884
|
+
},
|
|
885
|
+
"labels": {
|
|
886
|
+
'data types': d({
|
|
887
|
+
}),
|
|
888
|
+
'namespaces': d({
|
|
889
|
+
}),
|
|
890
|
+
},
|
|
891
|
+
}),
|
|
892
|
+
},
|
|
893
|
+
}),
|
|
894
|
+
},
|
|
895
|
+
"Type Selection": {
|
|
896
|
+
'data types': d({
|
|
897
|
+
}),
|
|
898
|
+
'namespaces': d({
|
|
899
|
+
"G": {
|
|
900
|
+
'data types': d({
|
|
901
|
+
}),
|
|
902
|
+
'namespaces': d({
|
|
903
|
+
"global type": {
|
|
904
|
+
'data types': d({
|
|
905
|
+
}),
|
|
906
|
+
'namespaces': d({
|
|
907
|
+
}),
|
|
908
|
+
},
|
|
909
|
+
"tail": {
|
|
910
|
+
'data types': d({
|
|
911
|
+
}),
|
|
912
|
+
'namespaces': d({
|
|
913
|
+
"O": {
|
|
914
|
+
'data types': d({
|
|
915
|
+
}),
|
|
916
|
+
'namespaces': d({
|
|
917
|
+
}),
|
|
918
|
+
},
|
|
919
|
+
}),
|
|
920
|
+
},
|
|
921
|
+
}),
|
|
922
|
+
},
|
|
923
|
+
}),
|
|
924
|
+
},
|
|
925
|
+
"Type Selection Tail": {
|
|
926
|
+
'data types': d({
|
|
927
|
+
}),
|
|
928
|
+
'namespaces': d({
|
|
929
|
+
"G": {
|
|
930
|
+
'data types': d({
|
|
931
|
+
}),
|
|
932
|
+
'namespaces': d({
|
|
933
|
+
"step type": {
|
|
934
|
+
'data types': d({
|
|
935
|
+
}),
|
|
936
|
+
'namespaces': d({
|
|
937
|
+
"TU": {
|
|
938
|
+
'data types': d({
|
|
939
|
+
}),
|
|
940
|
+
'namespaces': d({
|
|
941
|
+
"dictionary": {
|
|
942
|
+
'data types': d({
|
|
943
|
+
}),
|
|
944
|
+
'namespaces': d({
|
|
945
|
+
"G": {
|
|
946
|
+
'data types': d({
|
|
947
|
+
}),
|
|
948
|
+
'namespaces': d({
|
|
949
|
+
}),
|
|
950
|
+
},
|
|
951
|
+
}),
|
|
952
|
+
},
|
|
953
|
+
"group": {
|
|
954
|
+
'data types': d({
|
|
955
|
+
}),
|
|
956
|
+
'namespaces': d({
|
|
957
|
+
"G": {
|
|
958
|
+
'data types': d({
|
|
959
|
+
}),
|
|
960
|
+
'namespaces': d({
|
|
961
|
+
"property": {
|
|
962
|
+
'data types': d({
|
|
963
|
+
}),
|
|
964
|
+
'namespaces': d({
|
|
965
|
+
}),
|
|
966
|
+
},
|
|
967
|
+
}),
|
|
968
|
+
},
|
|
969
|
+
}),
|
|
970
|
+
},
|
|
971
|
+
"list": {
|
|
972
|
+
'data types': d({
|
|
973
|
+
}),
|
|
974
|
+
'namespaces': d({
|
|
975
|
+
"G": {
|
|
976
|
+
'data types': d({
|
|
977
|
+
}),
|
|
978
|
+
'namespaces': d({
|
|
979
|
+
}),
|
|
980
|
+
},
|
|
981
|
+
}),
|
|
982
|
+
},
|
|
983
|
+
"optional": {
|
|
984
|
+
'data types': d({
|
|
985
|
+
}),
|
|
986
|
+
'namespaces': d({
|
|
987
|
+
"G": {
|
|
988
|
+
'data types': d({
|
|
989
|
+
}),
|
|
990
|
+
'namespaces': d({
|
|
991
|
+
}),
|
|
992
|
+
},
|
|
993
|
+
}),
|
|
994
|
+
},
|
|
995
|
+
"state group": {
|
|
996
|
+
'data types': d({
|
|
997
|
+
}),
|
|
998
|
+
'namespaces': d({
|
|
999
|
+
"G": {
|
|
1000
|
+
'data types': d({
|
|
1001
|
+
}),
|
|
1002
|
+
'namespaces': d({
|
|
1003
|
+
"state": {
|
|
1004
|
+
'data types': d({
|
|
1005
|
+
}),
|
|
1006
|
+
'namespaces': d({
|
|
1007
|
+
}),
|
|
1008
|
+
},
|
|
1009
|
+
}),
|
|
1010
|
+
},
|
|
1011
|
+
}),
|
|
1012
|
+
},
|
|
1013
|
+
}),
|
|
1014
|
+
},
|
|
1015
|
+
}),
|
|
1016
|
+
},
|
|
1017
|
+
"tail": {
|
|
1018
|
+
'data types': d({
|
|
1019
|
+
}),
|
|
1020
|
+
'namespaces': d({
|
|
1021
|
+
"O": {
|
|
1022
|
+
'data types': d({
|
|
1023
|
+
}),
|
|
1024
|
+
'namespaces': d({
|
|
1025
|
+
}),
|
|
1026
|
+
},
|
|
1027
|
+
}),
|
|
1028
|
+
},
|
|
1029
|
+
}),
|
|
1030
|
+
},
|
|
1031
|
+
}),
|
|
1032
|
+
},
|
|
1033
|
+
}),
|
|
1034
|
+
},
|
|
1035
|
+
}
|