pareto 0.70.0 → 0.72.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.
Files changed (47) hide show
  1. package/auto.dist/data/boekhouding.data.d.ts +1 -1
  2. package/auto.dist/data/boekhouding.data.js +2 -2
  3. package/auto.dist/public/modules/cosmos_type_system_2_typescript_intermediate/auto.provided_interface_glossary.d.ts +9 -2
  4. package/auto.dist/public/modules/cosmos_type_system_2_typescript_intermediate/implementations/map_Data_Glossary_2_Blocks.alg.js +2 -2
  5. package/auto.dist/public/modules/filesystem_naming/implementations/create_Valid_File_Name.alg.js +2 -2
  6. package/auto.dist/public/modules/main/implementations/temp$_compile$_boekhouding.alg.js +3 -3
  7. package/auto.pareto/auto.dependencies/index.ts +1 -1
  8. package/auto.pareto/auto.dependencies/pareto-pure/$.data.ts +35 -33
  9. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.alan_light.data.ts → auto.alan_light.temp_in_between.data.ts} +492 -492
  10. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.boekhouding_unresolved.data.ts → auto.boekhouding.constrained_with_terminal_values.data.ts} +3186 -2955
  11. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.boekhouding_constrained.data.ts → auto.boekhouding.possibly_constrained.data.ts} +3263 -2954
  12. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.boekhouding_unconstrained.data.ts → auto.boekhouding.unconstrained_with_annotations.data.ts} +3183 -2955
  13. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.grammar.data.ts → auto.grammar.temp_in_between.data.ts} +308 -309
  14. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.graphviz.data.ts → auto.graphviz.temp_in_between.data.ts} +764 -764
  15. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.html.data.ts → auto.html.temp_in_between.data.ts} +3264 -3264
  16. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.tendril_possibly_constrained.data.ts → auto.liana_resolver.constrained_with_terminal_values.data.ts} +1033 -1169
  17. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.tendril.data.ts → auto.liana_resolver.possibly_constrained.data.ts} +1049 -1058
  18. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.tendril_unconstrained.data.ts → auto.liana_resolver.unconstrained_with_annotations.data.ts} +1034 -1034
  19. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.tendril_resolved.data.ts → auto.liana_schema.temp_in_between.data.ts} +998 -1009
  20. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.pareto.data.ts → auto.pareto_3gl_high.temp_in_between.data.ts} +1736 -1736
  21. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.cosmos_type_system.data.ts → auto.pareto_4gl_type_system.temp_in_between.data.ts} +2391 -2389
  22. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.cosmos_typescript.data.ts → auto.pareto_4gl_typescript.temp_in_between.data.ts} +131 -131
  23. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.semantic_versioning.data.ts → auto.semantic_versioning.temp_in_between.data.ts} +122 -122
  24. package/auto.pareto/auto.dependencies/pareto-pure/modules/alan_light_2_fountain_pen_indented_file_with_escaped_strings/glossary.data.ts +1 -1
  25. package/auto.pareto/auto.dependencies/pareto-pure/modules/graphviz_2_fountain_pen_indented_file_with_escaped_strings/glossary.data.ts +1 -1
  26. package/auto.pareto/auto.dependencies/pareto-pure/modules/html_2_xml/glossary.data.ts +1 -1
  27. package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril_2_alan_light → liana_schema_2_alan_light}/glossary.data.ts +2 -2
  28. package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril_2_pareto → liana_schema_2_pareto_3gl_high}/glossary.data.ts +2 -2
  29. package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril_2_cosmos_type_system → liana_schema_2_pareto_4gl_type_system}/glossary.data.ts +7 -11
  30. package/auto.pareto/auto.dependencies/pareto-pure/modules/{pareto_2_typescript_intermediate → pareto_3gl_high_2_typescript_intermediate}/glossary.data.ts +1 -1
  31. package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_type_system_2_graphviz → pareto_4gl_type_system_2_graphviz}/glossary.data.ts +2 -2
  32. package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_type_system_2_indented_file_with_escaped_strings → pareto_4gl_type_system_2_indented_file_with_escaped_strings}/glossary.data.ts +1 -1
  33. package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_type_system_2_pareto → pareto_4gl_type_system_2_pareto_3gl_high}/glossary.data.ts +2 -2
  34. package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_typescript_2_fountain_pen_directory → pareto_4gl_typescript_2_fountain_pen_directory}/glossary.data.ts +2 -2
  35. package/auto.pareto/auto.dependencies/pareto-pure/modules/semantic_versioning_from_text/glossary.data.ts +1 -1
  36. package/auto.pareto/modules/cosmos_type_system_2_typescript_intermediate/glossary.data.ts +1 -1
  37. package/auto.pareto/modules/pareto_2_fountain_pen/glossary.data.ts +1 -1
  38. package/package.json +3 -3
  39. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_resolved.data.ts +0 -2955
  40. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril_2_alan_light → liana_schema_2_alan_light}/api.data.ts +0 -0
  41. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril_2_pareto → liana_schema_2_pareto_3gl_high}/api.data.ts +0 -0
  42. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{tendril_2_cosmos_type_system → liana_schema_2_pareto_4gl_type_system}/api.data.ts +0 -0
  43. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{pareto_2_typescript_intermediate → pareto_3gl_high_2_typescript_intermediate}/api.data.ts +0 -0
  44. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_type_system_2_graphviz → pareto_4gl_type_system_2_graphviz}/api.data.ts +0 -0
  45. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_type_system_2_indented_file_with_escaped_strings → pareto_4gl_type_system_2_indented_file_with_escaped_strings}/api.data.ts +0 -0
  46. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_type_system_2_pareto → pareto_4gl_type_system_2_pareto_3gl_high}/api.data.ts +0 -0
  47. /package/auto.pareto/auto.dependencies/pareto-pure/modules/{cosmos_typescript_2_fountain_pen_directory → pareto_4gl_typescript_2_fountain_pen_directory}/api.data.ts +0 -0
package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.cosmos_type_system.data.ts → auto.pareto_4gl_type_system.temp_in_between.data.ts} RENAMED
@@ -1,2390 +1,2392 @@
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
- }),
11
- 'imports': d({
12
- }),
13
- 'root': {
14
- 'data types': d({
15
- "API": {
16
- 'parameters': d({
17
- }),
18
- 'type': ['group', d<g_cosmos.D.Data__Type>({
19
- "algorithms": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
20
- "definition": ['component', ['type', {
21
- 'context': ['local', null],
22
- 'tailXX': a([
23
- ]),
24
- 'type arguments': d({
25
- }),
26
- 'typeXX': "Algorithm Type Reference",
27
- }]],
28
- "dependencies": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
29
- "algorithm type": ['component', ['type', {
30
- 'context': ['local', null],
31
- 'tailXX': a([
32
- ]),
33
- 'type arguments': d({
34
- }),
35
- 'typeXX': "Algorithm Type Reference",
36
- }]],
37
- "module": ['text', null],
38
- "type": ['state group', d({
39
- "library dependency": ['text', null],
40
- "private": ['nothing', null],
41
- "public": ['nothing', null],
42
- "sibling": ['nothing', null],
43
- })],
44
- "type arguments": ['dictionary', ['state group', d({
45
- "api parameter": ['text', null],
46
- "data type": ['text', null],
47
- })]],
48
- })]],
49
- })]],
50
- "provided interface": ['component', ['type', {
51
- 'context': ['local', null],
52
- 'tailXX': a([
53
- ]),
54
- 'type arguments': d({
55
- }),
56
- 'typeXX': "Glossary",
57
- }]],
58
- })],
59
- },
60
- "Algorithm Type Reference": {
61
- 'parameters': d({
62
- }),
63
- 'type': ['group', d<g_cosmos.D.Data__Type>({
64
- "algorithm type": ['text', null],
65
- })],
66
- },
67
- "Arguments": {
68
- 'parameters': d({
69
- }),
70
- 'type': ['dictionary', ['component', ['type', {
71
- 'context': ['local', null],
72
- 'tailXX': a([
73
- ]),
74
- 'type arguments': d({
75
- }),
76
- 'typeXX': "Data Type Specifier",
77
- }]]],
78
- },
79
- "Asynchronous Interface Reference": {
80
- 'parameters': d({
81
- }),
82
- 'type': ['group', d<g_cosmos.D.Data__Type>({
83
- "context": ['state group', d({
84
- "import": ['group', d<g_cosmos.D.Data__Type>({
85
- "glossary": ['component', ['type', {
86
- 'context': ['local', null],
87
- 'tailXX': a([
88
- ]),
89
- 'type arguments': d({
90
- }),
91
- 'typeXX': "Glossary Reference",
92
- }]],
93
- })],
94
- "local": ['nothing', null],
95
- })],
96
- "interfaceXX": ['text', null],
97
- "type arguments": ['component', ['type', {
98
- 'context': ['local', null],
99
- 'tailXX': a([
100
- ]),
101
- 'type arguments': d({
102
- }),
103
- 'typeXX': "Arguments",
104
- }]],
105
- })],
106
- },
107
- "Asynchronous Interface Type": {
108
- 'parameters': d({
109
- }),
110
- 'type': ['state group', d({
111
- "choice": ['group', d<g_cosmos.D.Data__Type>({
112
- "options": ['dictionary', ['component', ['type', {
113
- 'context': ['local', null],
114
- 'tailXX': a([
115
- ]),
116
- 'type arguments': d({
117
- }),
118
- 'typeXX': "Asynchronous Interface Type",
119
- }]]],
120
- })],
121
- "method": ['group', d<g_cosmos.D.Data__Type>({
122
- "data": ['optional', ['component', ['type', {
123
- 'context': ['local', null],
124
- 'tailXX': a([
125
- ]),
126
- 'type arguments': d({
127
- }),
128
- 'typeXX': "Data Type Specifier",
129
- }]]],
130
- "interface": ['optional', ['component', ['type', {
131
- 'context': ['local', null],
132
- 'tailXX': a([
133
- ]),
134
- 'type arguments': d({
135
- }),
136
- 'typeXX': "Asynchronous Interface Type",
137
- }]]],
138
- })],
139
- "reference": ['component', ['type', {
140
- 'context': ['local', null],
141
- 'tailXX': a([
142
- ]),
143
- 'type arguments': d({
144
- }),
145
- 'typeXX': "Asynchronous Interface Reference",
146
- }]],
147
- "streamconsumer": ['group', d<g_cosmos.D.Data__Type>({
148
- "data": ['component', ['type', {
149
- 'context': ['local', null],
150
- 'tailXX': a([
151
- ]),
152
- 'type arguments': d({
153
- }),
154
- 'typeXX': "Asynchronous Interface Type",
155
- }]],
156
- "end": ['optional', ['component', ['type', {
157
- 'context': ['local', null],
158
- 'tailXX': a([
159
- ]),
160
- 'type arguments': d({
161
- }),
162
- 'typeXX': "Asynchronous Interface Type",
163
- }]]],
164
- })],
165
- })],
166
- },
167
- "Composite Transformations": {
168
- 'parameters': d({
169
- }),
170
- 'type': ['group', d<g_cosmos.D.Data__Type>({
171
- "higher glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
172
- "types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
173
- "lower glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
174
- "target types": ['dictionary', ['component', ['type', {
175
- 'context': ['local', null],
176
- 'tailXX': a([
177
- ]),
178
- 'type arguments': d({
179
- }),
180
- 'typeXX': "Transformation",
181
- }]]],
182
- })]],
183
- })]],
184
- })]],
185
- })],
186
- },
187
- "Data Glossary": {
188
- 'parameters': d({
189
- }),
190
- 'type': ['group', d<g_cosmos.D.Data__Type>({
191
- "glossary parameters": ['component', ['type', {
192
- 'context': ['local', null],
193
- 'tailXX': a([
194
- ]),
195
- 'type arguments': d({
196
- }),
197
- 'typeXX': "Parameters",
198
- }]],
199
- "imports": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
200
- "glossary": ['component', ['type', {
201
- 'context': ['local', null],
202
- 'tailXX': a([
203
- ]),
204
- 'type arguments': d({
205
- }),
206
- 'typeXX': "Data Glossary",
207
- }]],
208
- "type arguments": ['component', ['type', {
209
- 'context': ['local', null],
210
- 'tailXX': a([
211
- ]),
212
- 'type arguments': d({
213
- }),
214
- 'typeXX': "Arguments",
215
- }]],
216
- })]],
217
- "root": ['component', ['type', {
218
- 'context': ['local', null],
219
- 'tailXX': a([
220
- ]),
221
- 'type arguments': d({
222
- }),
223
- 'typeXX': "Namespace",
224
- }]],
225
- })],
226
- },
227
- "Data Or Synchronous Interface": {
228
- 'parameters': d({
229
- }),
230
- 'type': ['state group', d({
231
- "data": ['component', ['type', {
232
- 'context': ['local', null],
233
- 'tailXX': a([
234
- ]),
235
- 'type arguments': d({
236
- }),
237
- 'typeXX': "Data Type Specifier",
238
- }]],
239
- "interface": ['component', ['type', {
240
- 'context': ['local', null],
241
- 'tailXX': a([
242
- ]),
243
- 'type arguments': d({
244
- }),
245
- 'typeXX': "Synchronous Interface Reference",
246
- }]],
247
- })],
248
- },
249
- "Data Type": {
250
- 'parameters': d({
251
- }),
252
- 'type': ['state group', d({
253
- "boolean": ['nothing', null],
254
- "component": ['component', ['type', {
255
- 'context': ['local', null],
256
- 'tailXX': a([
257
- ]),
258
- 'type arguments': d({
259
- }),
260
- 'typeXX': "Data Type Specifier",
261
- }]],
262
- "dictionary": ['component', ['type', {
263
- 'context': ['local', null],
264
- 'tailXX': a([
265
- ]),
266
- 'type arguments': d({
267
- }),
268
- 'typeXX': "Data Type",
269
- }]],
270
- "group": ['dictionary', ['component', ['type', {
271
- 'context': ['local', null],
272
- 'tailXX': a([
273
- ]),
274
- 'type arguments': d({
275
- }),
276
- 'typeXX': "Data Type",
277
- }]]],
278
- "integer": ['nothing', null],
279
- "link": ['group', d<g_cosmos.D.Data__Type>({
280
- "forward": ['boolean', null],
281
- "target": ['component', ['type', {
282
- 'context': ['local', null],
283
- 'tailXX': a([
284
- ]),
285
- 'type arguments': d({
286
- }),
287
- 'typeXX': "Data Type Specifier",
288
- }]],
289
- "value": ['component', ['type', {
290
- 'context': ['local', null],
291
- 'tailXX': a([
292
- ]),
293
- 'type arguments': d({
294
- }),
295
- 'typeXX': "Data Type",
296
- }]],
297
- })],
298
- "list": ['component', ['type', {
299
- 'context': ['local', null],
300
- 'tailXX': a([
301
- ]),
302
- 'type arguments': d({
303
- }),
304
- 'typeXX': "Data Type",
305
- }]],
306
- "nothing": ['nothing', null],
307
- "optional": ['component', ['type', {
308
- 'context': ['local', null],
309
- 'tailXX': a([
310
- ]),
311
- 'type arguments': d({
312
- }),
313
- 'typeXX': "Data Type",
314
- }]],
315
- "state group": ['dictionary', ['component', ['type', {
316
- 'context': ['local', null],
317
- 'tailXX': a([
318
- ]),
319
- 'type arguments': d({
320
- }),
321
- 'typeXX': "Data Type",
322
- }]]],
323
- "text": ['nothing', null],
324
- })],
325
- },
326
- "Data Type Reference": {
327
- 'parameters': d({
328
- }),
329
- 'type': ['group', d<g_cosmos.D.Data__Type>({
330
- "type": ['text', null],
331
- "type arguments": ['component', ['type', {
332
- 'context': ['local', null],
333
- 'tailXX': a([
334
- ]),
335
- 'type arguments': d({
336
- }),
337
- 'typeXX': "Arguments",
338
- }]],
339
- })],
340
- },
341
- "Data Type Specifier": {
342
- 'parameters': d({
343
- }),
344
- 'type': ['state group', d({
345
- "glossary parameterXX": ['text', null],
346
- "type": ['group', d<g_cosmos.D.Data__Type>({
347
- "context": ['state group', d({
348
- "import": ['group', d<g_cosmos.D.Data__Type>({
349
- "glossary": ['component', ['type', {
350
- 'context': ['local', null],
351
- 'tailXX': a([
352
- ]),
353
- 'type arguments': d({
354
- }),
355
- 'typeXX': "Glossary Reference",
356
- }]],
357
- })],
358
- "local": ['nothing', null],
359
- })],
360
- "tailXX": ['list', ['text', null]],
361
- "type arguments": ['component', ['type', {
362
- 'context': ['local', null],
363
- 'tailXX': a([
364
- ]),
365
- 'type arguments': d({
366
- }),
367
- 'typeXX': "Arguments",
368
- }]],
369
- "typeXX": ['text', null],
370
- })],
371
- "type parameterXX": ['text', null],
372
- })],
373
- },
374
- "Glossary": {
375
- 'parameters': d({
376
- }),
377
- 'type': ['group', d<g_cosmos.D.Data__Type>({
378
- "algorithm types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
379
- "parameters": ['component', ['type', {
380
- 'context': ['local', null],
381
- 'tailXX': a([
382
- ]),
383
- 'type arguments': d({
384
- }),
385
- 'typeXX': "Parameters",
386
- }]],
387
- "type": ['state group', d({
388
- "asynchronous function": ['group', d<g_cosmos.D.Data__Type>({
389
- "in": ['component', ['type', {
390
- 'context': ['local', null],
391
- 'tailXX': a([
392
- ]),
393
- 'type arguments': d({
394
- }),
395
- 'typeXX': "Data Type Specifier",
396
- }]],
397
- "out": ['component', ['type', {
398
- 'context': ['local', null],
399
- 'tailXX': a([
400
- ]),
401
- 'type arguments': d({
402
- }),
403
- 'typeXX': "Data Type Specifier",
404
- }]],
405
- })],
406
- "interface initializer": ['group', d<g_cosmos.D.Data__Type>({
407
- "downstreams": ['dictionary', ['component', ['type', {
408
- 'context': ['local', null],
409
- 'tailXX': a([
410
- ]),
411
- 'type arguments': d({
412
- }),
413
- 'typeXX': "Asynchronous Interface Reference",
414
- }]]],
415
- "interface": ['component', ['type', {
416
- 'context': ['local', null],
417
- 'tailXX': a([
418
- ]),
419
- 'type arguments': d({
420
- }),
421
- 'typeXX': "Asynchronous Interface Reference",
422
- }]],
423
- })],
424
- "procedure": ['group', d<g_cosmos.D.Data__Type>({
425
- "in": ['component', ['type', {
426
- 'context': ['local', null],
427
- 'tailXX': a([
428
- ]),
429
- 'type arguments': d({
430
- }),
431
- 'typeXX': "Data Or Synchronous Interface",
432
- }]],
433
- "out": ['component', ['type', {
434
- 'context': ['local', null],
435
- 'tailXX': a([
436
- ]),
437
- 'type arguments': d({
438
- }),
439
- 'typeXX': "Synchronous Interface Reference",
440
- }]],
441
- })],
442
- "resource initializer": ['group', d<g_cosmos.D.Data__Type>({
443
- "consumer": ['component', ['type', {
444
- 'context': ['local', null],
445
- 'tailXX': a([
446
- ]),
447
- 'type arguments': d({
448
- }),
449
- 'typeXX': "Asynchronous Interface Reference",
450
- }]],
451
- "request": ['component', ['type', {
452
- 'context': ['local', null],
453
- 'tailXX': a([
454
- ]),
455
- 'type arguments': d({
456
- }),
457
- 'typeXX': "Data Type Specifier",
458
- }]],
459
- })],
460
- "synchronous function": ['group', d<g_cosmos.D.Data__Type>({
461
- "in": ['component', ['type', {
462
- 'context': ['local', null],
463
- 'tailXX': a([
464
- ]),
465
- 'type arguments': d({
466
- }),
467
- 'typeXX': "Data Or Synchronous Interface",
468
- }]],
469
- "out": ['component', ['type', {
470
- 'context': ['local', null],
471
- 'tailXX': a([
472
- ]),
473
- 'type arguments': d({
474
- }),
475
- 'typeXX': "Data Type Specifier",
476
- }]],
477
- })],
478
- })],
479
- })]],
480
- "data glossary": ['component', ['type', {
481
- 'context': ['local', null],
482
- 'tailXX': a([
483
- ]),
484
- 'type arguments': d({
485
- }),
486
- 'typeXX': "Data Glossary",
487
- }]],
488
- "interface types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
489
- "parameters": ['component', ['type', {
490
- 'context': ['local', null],
491
- 'tailXX': a([
492
- ]),
493
- 'type arguments': d({
494
- }),
495
- 'typeXX': "Parameters",
496
- }]],
497
- "type": ['state group', d({
498
- "asynchronous": ['group', d<g_cosmos.D.Data__Type>({
499
- "interface": ['component', ['type', {
500
- 'context': ['local', null],
501
- 'tailXX': a([
502
- ]),
503
- 'type arguments': d({
504
- }),
505
- 'typeXX': "Asynchronous Interface Type",
506
- }]],
507
- })],
508
- "synchronous": ['group', d<g_cosmos.D.Data__Type>({
509
- "interface": ['component', ['type', {
510
- 'context': ['local', null],
511
- 'tailXX': a([
512
- ]),
513
- 'type arguments': d({
514
- }),
515
- 'typeXX': "Synchronous Interface Type",
516
- }]],
517
- })],
518
- })],
519
- })]],
520
- })],
521
- },
522
- "Glossary Reference": {
523
- 'parameters': d({
524
- }),
525
- 'type': ['group', d<g_cosmos.D.Data__Type>({
526
- "glossary": ['text', null],
527
- })],
528
- },
529
- "Library": {
530
- 'parameters': d({
531
- }),
532
- 'type': ['group', d<g_cosmos.D.Data__Type>({
533
- "author": ['text', null],
534
- "description": ['text', null],
535
- "license": ['text', null],
536
- "module sets": ['group', d<g_cosmos.D.Data__Type>({
537
- "private": ['component', ['type', {
538
- 'context': ['local', null],
539
- 'tailXX': a([
540
- ]),
541
- 'type arguments': d({
542
- }),
543
- 'typeXX': "Module Set",
544
- }]],
545
- "public": ['component', ['type', {
546
- 'context': ['local', null],
547
- 'tailXX': a([
548
- ]),
549
- 'type arguments': d({
550
- }),
551
- 'typeXX': "Module Set",
552
- }]],
553
- })],
554
- "type": ['state group', d({
555
- "composite": ['group', d<g_cosmos.D.Data__Type>({
556
- "dependencies": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
557
- "library": ['component', ['type', {
558
- 'context': ['local', null],
559
- 'tailXX': a([
560
- ]),
561
- 'type arguments': d({
562
- }),
563
- 'typeXX': "Library",
564
- }]],
565
- "version": ['text', null],
566
- })]],
567
- "pure": ['boolean', null],
568
- })],
569
- "primitive": ['group', d<g_cosmos.D.Data__Type>({
570
- })],
571
- })],
572
- })],
573
- },
574
- "Module Set": {
575
- 'parameters': d({
576
- }),
577
- 'type': ['group', d<g_cosmos.D.Data__Type>({
578
- "glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
579
- "description": ['text', null],
580
- "glossary": ['component', ['type', {
581
- 'context': ['local', null],
582
- 'tailXX': a([
583
- ]),
584
- 'type arguments': d({
585
- }),
586
- 'typeXX': "Data Glossary",
587
- }]],
588
- })]],
589
- "modules": ['dictionary', ['component', ['type', {
590
- 'context': ['local', null],
591
- 'tailXX': a([
592
- ]),
593
- 'type arguments': d({
594
- }),
595
- 'typeXX': "API",
596
- }]]],
597
- "transformations": ['group', d<g_cosmos.D.Data__Type>({
598
- "enrich": ['dictionary', ['component', ['type', {
599
- 'context': ['local', null],
600
- 'tailXX': a([
601
- ]),
602
- 'type arguments': d({
603
- }),
604
- 'typeXX': "Transformations",
605
- }]]],
606
- "yield": ['dictionary', ['component', ['type', {
607
- 'context': ['local', null],
608
- 'tailXX': a([
609
- ]),
610
- 'type arguments': d({
611
- }),
612
- 'typeXX': "Transformations",
613
- }]]],
614
- })],
615
- })],
616
- },
617
- "Namespace": {
618
- 'parameters': d({
619
- }),
620
- 'type': ['group', d<g_cosmos.D.Data__Type>({
621
- "data types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
622
- "parameters": ['component', ['type', {
623
- 'context': ['local', null],
624
- 'tailXX': a([
625
- ]),
626
- 'type arguments': d({
627
- }),
628
- 'typeXX': "Parameters",
629
- }]],
630
- "type": ['component', ['type', {
631
- 'context': ['local', null],
632
- 'tailXX': a([
633
- ]),
634
- 'type arguments': d({
635
- }),
636
- 'typeXX': "Data Type",
637
- }]],
638
- })]],
639
- "namespaces": ['dictionary', ['component', ['type', {
640
- 'context': ['local', null],
641
- 'tailXX': a([
642
- ]),
643
- 'type arguments': d({
644
- }),
645
- 'typeXX': "Namespace",
646
- }]]],
647
- })],
648
- },
649
- "Parameters": {
650
- 'parameters': d({
651
- }),
652
- 'type': ['dictionary', ['nothing', null]],
653
- },
654
- "Synchronous Interface Reference": {
655
- 'parameters': d({
656
- }),
657
- 'type': ['group', d<g_cosmos.D.Data__Type>({
658
- "context": ['state group', d({
659
- "import": ['group', d<g_cosmos.D.Data__Type>({
660
- "glossary": ['component', ['type', {
661
- 'context': ['local', null],
662
- 'tailXX': a([
663
- ]),
664
- 'type arguments': d({
665
- }),
666
- 'typeXX': "Glossary Reference",
667
- }]],
668
- "interfaceXX": ['text', null],
669
- })],
670
- "local": ['group', d<g_cosmos.D.Data__Type>({
671
- "interfaceXX": ['text', null],
672
- })],
673
- })],
674
- "type arguments": ['component', ['type', {
675
- 'context': ['local', null],
676
- 'tailXX': a([
677
- ]),
678
- 'type arguments': d({
679
- }),
680
- 'typeXX': "Arguments",
681
- }]],
682
- })],
683
- },
684
- "Synchronous Interface Type": {
685
- 'parameters': d({
686
- }),
687
- 'type': ['state group', d({
688
- "group": ['group', d<g_cosmos.D.Data__Type>({
689
- "members": ['dictionary', ['component', ['type', {
690
- 'context': ['local', null],
691
- 'tailXX': a([
692
- ]),
693
- 'type arguments': d({
694
- }),
695
- 'typeXX': "Synchronous Interface Type",
696
- }]]],
697
- })],
698
- "method": ['group', d<g_cosmos.D.Data__Type>({
699
- "data": ['optional', ['component', ['type', {
700
- 'context': ['local', null],
701
- 'tailXX': a([
702
- ]),
703
- 'type arguments': d({
704
- }),
705
- 'typeXX': "Data Type Specifier",
706
- }]]],
707
- "interface": ['optional', ['component', ['type', {
708
- 'context': ['local', null],
709
- 'tailXX': a([
710
- ]),
711
- 'type arguments': d({
712
- }),
713
- 'typeXX': "Synchronous Interface Type",
714
- }]]],
715
- })],
716
- "reference": ['component', ['type', {
717
- 'context': ['local', null],
718
- 'tailXX': a([
719
- ]),
720
- 'type arguments': d({
721
- }),
722
- 'typeXX': "Synchronous Interface Reference",
723
- }]],
724
- })],
725
- },
726
- "Transformation": {
727
- 'parameters': d({
728
- }),
729
- 'type': ['group', d<g_cosmos.D.Data__Type>({
730
- "parameters": ['dictionary', ['component', ['type', {
731
- 'context': ['local', null],
732
- 'tailXX': a([
733
- ]),
734
- 'type arguments': d({
735
- }),
736
- 'typeXX': "Data Type Reference",
737
- }]]],
738
- })],
739
- },
740
- "Transformations": {
741
- 'parameters': d({
742
- }),
743
- 'type': ['group', d<g_cosmos.D.Data__Type>({
744
- "atom": ['group', d<g_cosmos.D.Data__Type>({
745
- "boolean": ['dictionary', ['component', ['type', {
746
- 'context': ['local', null],
747
- 'tailXX': a([
748
- ]),
749
- 'type arguments': d({
750
- }),
751
- 'typeXX': "Transformation",
752
- }]]],
753
- "dictionary": ['dictionary', ['component', ['type', {
754
- 'context': ['local', null],
755
- 'tailXX': a([
756
- ]),
757
- 'type arguments': d({
758
- }),
759
- 'typeXX': "Transformation",
760
- }]]],
761
- "integer": ['dictionary', ['component', ['type', {
762
- 'context': ['local', null],
763
- 'tailXX': a([
764
- ]),
765
- 'type arguments': d({
766
- }),
767
- 'typeXX': "Transformation",
768
- }]]],
769
- "list": ['dictionary', ['component', ['type', {
770
- 'context': ['local', null],
771
- 'tailXX': a([
772
- ]),
773
- 'type arguments': d({
774
- }),
775
- 'typeXX': "Transformation",
776
- }]]],
777
- "text": ['dictionary', ['component', ['type', {
778
- 'context': ['local', null],
779
- 'tailXX': a([
780
- ]),
781
- 'type arguments': d({
782
- }),
783
- 'typeXX': "Transformation",
784
- }]]],
785
- })],
786
- "composite": ['group', d<g_cosmos.D.Data__Type>({
787
- "external libraries": ['dictionary', ['component', ['type', {
788
- 'context': ['local', null],
789
- 'tailXX': a([
790
- ]),
791
- 'type arguments': d({
792
- }),
793
- 'typeXX': "Composite Transformations",
794
- }]]],
795
- "local": ['component', ['type', {
796
- 'context': ['local', null],
797
- 'tailXX': a([
798
- ]),
799
- 'type arguments': d({
800
- }),
801
- 'typeXX': "Composite Transformations",
802
- }]],
803
- })],
804
- "glossary": ['component', ['type', {
805
- 'context': ['local', null],
806
- 'tailXX': a([
807
- ]),
808
- 'type arguments': d({
809
- }),
810
- 'typeXX': "Data Glossary",
811
- }]],
812
- })],
813
- },
814
- }),
815
- 'namespaces': d({
816
- "API": {
817
- 'data types': d({
818
- }),
819
- 'namespaces': d({
820
- "G": {
821
- 'data types': d({
822
- }),
823
- 'namespaces': d({
824
- "algorithms": {
825
- 'data types': d({
826
- }),
827
- 'namespaces': d({
828
- "DX": {
829
- 'data types': d({
830
- }),
831
- 'namespaces': d({
832
- "G": {
833
- 'data types': d({
834
- }),
835
- 'namespaces': d({
836
- "definition": {
837
- 'data types': d({
838
- }),
839
- 'namespaces': d({
840
- }),
841
- },
842
- "dependencies": {
843
- 'data types': d({
844
- }),
845
- 'namespaces': d({
846
- "DX": {
847
- 'data types': d({
848
- }),
849
- 'namespaces': d({
850
- "G": {
851
- 'data types': d({
852
- }),
853
- 'namespaces': d({
854
- "algorithm type": {
855
- 'data types': d({
856
- }),
857
- 'namespaces': d({
858
- }),
859
- },
860
- "module": {
861
- 'data types': d({
862
- }),
863
- 'namespaces': d({
864
- }),
865
- },
866
- "type": {
867
- 'data types': d({
868
- }),
869
- 'namespaces': d({
870
- "TU": {
871
- 'data types': d({
872
- }),
873
- 'namespaces': d({
874
- "library dependency": {
875
- 'data types': d({
876
- }),
877
- 'namespaces': d({
878
- }),
879
- },
880
- "private": {
881
- 'data types': d({
882
- }),
883
- 'namespaces': d({
884
- }),
885
- },
886
- "public": {
887
- 'data types': d({
888
- }),
889
- 'namespaces': d({
890
- }),
891
- },
892
- "sibling": {
893
- 'data types': d({
894
- }),
895
- 'namespaces': d({
896
- }),
897
- },
898
- }),
899
- },
900
- }),
901
- },
902
- "type arguments": {
903
- 'data types': d({
904
- }),
905
- 'namespaces': d({
906
- "DX": {
907
- 'data types': d({
908
- }),
909
- 'namespaces': d({
910
- "TU": {
911
- 'data types': d({
912
- }),
913
- 'namespaces': d({
914
- "api parameter": {
915
- 'data types': d({
916
- }),
917
- 'namespaces': d({
918
- }),
919
- },
920
- "data type": {
921
- 'data types': d({
922
- }),
923
- 'namespaces': d({
924
- }),
925
- },
926
- }),
927
- },
928
- }),
929
- },
930
- }),
931
- },
932
- }),
933
- },
934
- }),
935
- },
936
- }),
937
- },
938
- }),
939
- },
940
- }),
941
- },
942
- }),
943
- },
944
- "provided interface": {
945
- 'data types': d({
946
- }),
947
- 'namespaces': d({
948
- }),
949
- },
950
- }),
951
- },
952
- }),
953
- },
954
- "Algorithm Type Reference": {
955
- 'data types': d({
956
- }),
957
- 'namespaces': d({
958
- "G": {
959
- 'data types': d({
960
- }),
961
- 'namespaces': d({
962
- "algorithm type": {
963
- 'data types': d({
964
- }),
965
- 'namespaces': d({
966
- }),
967
- },
968
- }),
969
- },
970
- }),
971
- },
972
- "Arguments": {
973
- 'data types': d({
974
- }),
975
- 'namespaces': d({
976
- "DX": {
977
- 'data types': d({
978
- }),
979
- 'namespaces': d({
980
- }),
981
- },
982
- }),
983
- },
984
- "Asynchronous Interface Reference": {
985
- 'data types': d({
986
- }),
987
- 'namespaces': d({
988
- "G": {
989
- 'data types': d({
990
- }),
991
- 'namespaces': d({
992
- "context": {
993
- 'data types': d({
994
- }),
995
- 'namespaces': d({
996
- "TU": {
997
- 'data types': d({
998
- }),
999
- 'namespaces': d({
1000
- "import": {
1001
- 'data types': d({
1002
- }),
1003
- 'namespaces': d({
1004
- "G": {
1005
- 'data types': d({
1006
- }),
1007
- 'namespaces': d({
1008
- "glossary": {
1009
- 'data types': d({
1010
- }),
1011
- 'namespaces': d({
1012
- }),
1013
- },
1014
- }),
1015
- },
1016
- }),
1017
- },
1018
- "local": {
1019
- 'data types': d({
1020
- }),
1021
- 'namespaces': d({
1022
- }),
1023
- },
1024
- }),
1025
- },
1026
- }),
1027
- },
1028
- "interfaceXX": {
1029
- 'data types': d({
1030
- }),
1031
- 'namespaces': d({
1032
- }),
1033
- },
1034
- "type arguments": {
1035
- 'data types': d({
1036
- }),
1037
- 'namespaces': d({
1038
- }),
1039
- },
1040
- }),
1041
- },
1042
- }),
1043
- },
1044
- "Asynchronous Interface Type": {
1045
- 'data types': d({
1046
- }),
1047
- 'namespaces': d({
1048
- "TU": {
1049
- 'data types': d({
1050
- }),
1051
- 'namespaces': d({
1052
- "choice": {
1053
- 'data types': d({
1054
- }),
1055
- 'namespaces': d({
1056
- "G": {
1057
- 'data types': d({
1058
- }),
1059
- 'namespaces': d({
1060
- "options": {
1061
- 'data types': d({
1062
- }),
1063
- 'namespaces': d({
1064
- "DX": {
1065
- 'data types': d({
1066
- }),
1067
- 'namespaces': d({
1068
- }),
1069
- },
1070
- }),
1071
- },
1072
- }),
1073
- },
1074
- }),
1075
- },
1076
- "method": {
1077
- 'data types': d({
1078
- }),
1079
- 'namespaces': d({
1080
- "G": {
1081
- 'data types': d({
1082
- }),
1083
- 'namespaces': d({
1084
- "data": {
1085
- 'data types': d({
1086
- }),
1087
- 'namespaces': d({
1088
- "O": {
1089
- 'data types': d({
1090
- }),
1091
- 'namespaces': d({
1092
- }),
1093
- },
1094
- }),
1095
- },
1096
- "interface": {
1097
- 'data types': d({
1098
- }),
1099
- 'namespaces': d({
1100
- "O": {
1101
- 'data types': d({
1102
- }),
1103
- 'namespaces': d({
1104
- }),
1105
- },
1106
- }),
1107
- },
1108
- }),
1109
- },
1110
- }),
1111
- },
1112
- "reference": {
1113
- 'data types': d({
1114
- }),
1115
- 'namespaces': d({
1116
- }),
1117
- },
1118
- "streamconsumer": {
1119
- 'data types': d({
1120
- }),
1121
- 'namespaces': d({
1122
- "G": {
1123
- 'data types': d({
1124
- }),
1125
- 'namespaces': d({
1126
- "data": {
1127
- 'data types': d({
1128
- }),
1129
- 'namespaces': d({
1130
- }),
1131
- },
1132
- "end": {
1133
- 'data types': d({
1134
- }),
1135
- 'namespaces': d({
1136
- "O": {
1137
- 'data types': d({
1138
- }),
1139
- 'namespaces': d({
1140
- }),
1141
- },
1142
- }),
1143
- },
1144
- }),
1145
- },
1146
- }),
1147
- },
1148
- }),
1149
- },
1150
- }),
1151
- },
1152
- "Composite Transformations": {
1153
- 'data types': d({
1154
- }),
1155
- 'namespaces': d({
1156
- "G": {
1157
- 'data types': d({
1158
- }),
1159
- 'namespaces': d({
1160
- "higher glossaries": {
1161
- 'data types': d({
1162
- }),
1163
- 'namespaces': d({
1164
- "DX": {
1165
- 'data types': d({
1166
- }),
1167
- 'namespaces': d({
1168
- "G": {
1169
- 'data types': d({
1170
- }),
1171
- 'namespaces': d({
1172
- "types": {
1173
- 'data types': d({
1174
- }),
1175
- 'namespaces': d({
1176
- "DX": {
1177
- 'data types': d({
1178
- }),
1179
- 'namespaces': d({
1180
- "G": {
1181
- 'data types': d({
1182
- }),
1183
- 'namespaces': d({
1184
- "lower glossaries": {
1185
- 'data types': d({
1186
- }),
1187
- 'namespaces': d({
1188
- "DX": {
1189
- 'data types': d({
1190
- }),
1191
- 'namespaces': d({
1192
- "G": {
1193
- 'data types': d({
1194
- }),
1195
- 'namespaces': d({
1196
- "target types": {
1197
- 'data types': d({
1198
- }),
1199
- 'namespaces': d({
1200
- "DX": {
1201
- 'data types': d({
1202
- }),
1203
- 'namespaces': d({
1204
- }),
1205
- },
1206
- }),
1207
- },
1208
- }),
1209
- },
1210
- }),
1211
- },
1212
- }),
1213
- },
1214
- }),
1215
- },
1216
- }),
1217
- },
1218
- }),
1219
- },
1220
- }),
1221
- },
1222
- }),
1223
- },
1224
- }),
1225
- },
1226
- }),
1227
- },
1228
- }),
1229
- },
1230
- "Data Glossary": {
1231
- 'data types': d({
1232
- }),
1233
- 'namespaces': d({
1234
- "G": {
1235
- 'data types': d({
1236
- }),
1237
- 'namespaces': d({
1238
- "glossary parameters": {
1239
- 'data types': d({
1240
- }),
1241
- 'namespaces': d({
1242
- }),
1243
- },
1244
- "imports": {
1245
- 'data types': d({
1246
- }),
1247
- 'namespaces': d({
1248
- "DX": {
1249
- 'data types': d({
1250
- }),
1251
- 'namespaces': d({
1252
- "G": {
1253
- 'data types': d({
1254
- }),
1255
- 'namespaces': d({
1256
- "glossary": {
1257
- 'data types': d({
1258
- }),
1259
- 'namespaces': d({
1260
- }),
1261
- },
1262
- "type arguments": {
1263
- 'data types': d({
1264
- }),
1265
- 'namespaces': d({
1266
- }),
1267
- },
1268
- }),
1269
- },
1270
- }),
1271
- },
1272
- }),
1273
- },
1274
- "root": {
1275
- 'data types': d({
1276
- }),
1277
- 'namespaces': d({
1278
- }),
1279
- },
1280
- }),
1281
- },
1282
- }),
1283
- },
1284
- "Data Or Synchronous Interface": {
1285
- 'data types': d({
1286
- }),
1287
- 'namespaces': d({
1288
- "TU": {
1289
- 'data types': d({
1290
- }),
1291
- 'namespaces': d({
1292
- "data": {
1293
- 'data types': d({
1294
- }),
1295
- 'namespaces': d({
1296
- }),
1297
- },
1298
- "interface": {
1299
- 'data types': d({
1300
- }),
1301
- 'namespaces': d({
1302
- }),
1303
- },
1304
- }),
1305
- },
1306
- }),
1307
- },
1308
- "Data Type": {
1309
- 'data types': d({
1310
- }),
1311
- 'namespaces': d({
1312
- "TU": {
1313
- 'data types': d({
1314
- }),
1315
- 'namespaces': d({
1316
- "boolean": {
1317
- 'data types': d({
1318
- }),
1319
- 'namespaces': d({
1320
- }),
1321
- },
1322
- "component": {
1323
- 'data types': d({
1324
- }),
1325
- 'namespaces': d({
1326
- }),
1327
- },
1328
- "dictionary": {
1329
- 'data types': d({
1330
- }),
1331
- 'namespaces': d({
1332
- }),
1333
- },
1334
- "group": {
1335
- 'data types': d({
1336
- }),
1337
- 'namespaces': d({
1338
- "DX": {
1339
- 'data types': d({
1340
- }),
1341
- 'namespaces': d({
1342
- }),
1343
- },
1344
- }),
1345
- },
1346
- "integer": {
1347
- 'data types': d({
1348
- }),
1349
- 'namespaces': d({
1350
- }),
1351
- },
1352
- "link": {
1353
- 'data types': d({
1354
- }),
1355
- 'namespaces': d({
1356
- "G": {
1357
- 'data types': d({
1358
- }),
1359
- 'namespaces': d({
1360
- "forward": {
1361
- 'data types': d({
1362
- }),
1363
- 'namespaces': d({
1364
- }),
1365
- },
1366
- "target": {
1367
- 'data types': d({
1368
- }),
1369
- 'namespaces': d({
1370
- }),
1371
- },
1372
- "value": {
1373
- 'data types': d({
1374
- }),
1375
- 'namespaces': d({
1376
- }),
1377
- },
1378
- }),
1379
- },
1380
- }),
1381
- },
1382
- "list": {
1383
- 'data types': d({
1384
- }),
1385
- 'namespaces': d({
1386
- }),
1387
- },
1388
- "nothing": {
1389
- 'data types': d({
1390
- }),
1391
- 'namespaces': d({
1392
- }),
1393
- },
1394
- "optional": {
1395
- 'data types': d({
1396
- }),
1397
- 'namespaces': d({
1398
- }),
1399
- },
1400
- "state group": {
1401
- 'data types': d({
1402
- }),
1403
- 'namespaces': d({
1404
- "DX": {
1405
- 'data types': d({
1406
- }),
1407
- 'namespaces': d({
1408
- }),
1409
- },
1410
- }),
1411
- },
1412
- "text": {
1413
- 'data types': d({
1414
- }),
1415
- 'namespaces': d({
1416
- }),
1417
- },
1418
- }),
1419
- },
1420
- }),
1421
- },
1422
- "Data Type Reference": {
1423
- 'data types': d({
1424
- }),
1425
- 'namespaces': d({
1426
- "G": {
1427
- 'data types': d({
1428
- }),
1429
- 'namespaces': d({
1430
- "type": {
1431
- 'data types': d({
1432
- }),
1433
- 'namespaces': d({
1434
- }),
1435
- },
1436
- "type arguments": {
1437
- 'data types': d({
1438
- }),
1439
- 'namespaces': d({
1440
- }),
1441
- },
1442
- }),
1443
- },
1444
- }),
1445
- },
1446
- "Data Type Specifier": {
1447
- 'data types': d({
1448
- }),
1449
- 'namespaces': d({
1450
- "TU": {
1451
- 'data types': d({
1452
- }),
1453
- 'namespaces': d({
1454
- "glossary parameterXX": {
1455
- 'data types': d({
1456
- }),
1457
- 'namespaces': d({
1458
- }),
1459
- },
1460
- "type": {
1461
- 'data types': d({
1462
- }),
1463
- 'namespaces': d({
1464
- "G": {
1465
- 'data types': d({
1466
- }),
1467
- 'namespaces': d({
1468
- "context": {
1469
- 'data types': d({
1470
- }),
1471
- 'namespaces': d({
1472
- "TU": {
1473
- 'data types': d({
1474
- }),
1475
- 'namespaces': d({
1476
- "import": {
1477
- 'data types': d({
1478
- }),
1479
- 'namespaces': d({
1480
- "G": {
1481
- 'data types': d({
1482
- }),
1483
- 'namespaces': d({
1484
- "glossary": {
1485
- 'data types': d({
1486
- }),
1487
- 'namespaces': d({
1488
- }),
1489
- },
1490
- }),
1491
- },
1492
- }),
1493
- },
1494
- "local": {
1495
- 'data types': d({
1496
- }),
1497
- 'namespaces': d({
1498
- }),
1499
- },
1500
- }),
1501
- },
1502
- }),
1503
- },
1504
- "tailXX": {
1505
- 'data types': d({
1506
- }),
1507
- 'namespaces': d({
1508
- "A": {
1509
- 'data types': d({
1510
- }),
1511
- 'namespaces': d({
1512
- }),
1513
- },
1514
- }),
1515
- },
1516
- "type arguments": {
1517
- 'data types': d({
1518
- }),
1519
- 'namespaces': d({
1520
- }),
1521
- },
1522
- "typeXX": {
1523
- 'data types': d({
1524
- }),
1525
- 'namespaces': d({
1526
- }),
1527
- },
1528
- }),
1529
- },
1530
- }),
1531
- },
1532
- "type parameterXX": {
1533
- 'data types': d({
1534
- }),
1535
- 'namespaces': d({
1536
- }),
1537
- },
1538
- }),
1539
- },
1540
- }),
1541
- },
1542
- "Glossary": {
1543
- 'data types': d({
1544
- }),
1545
- 'namespaces': d({
1546
- "G": {
1547
- 'data types': d({
1548
- }),
1549
- 'namespaces': d({
1550
- "algorithm types": {
1551
- 'data types': d({
1552
- }),
1553
- 'namespaces': d({
1554
- "DX": {
1555
- 'data types': d({
1556
- }),
1557
- 'namespaces': d({
1558
- "G": {
1559
- 'data types': d({
1560
- }),
1561
- 'namespaces': d({
1562
- "parameters": {
1563
- 'data types': d({
1564
- }),
1565
- 'namespaces': d({
1566
- }),
1567
- },
1568
- "type": {
1569
- 'data types': d({
1570
- }),
1571
- 'namespaces': d({
1572
- "TU": {
1573
- 'data types': d({
1574
- }),
1575
- 'namespaces': d({
1576
- "asynchronous function": {
1577
- 'data types': d({
1578
- }),
1579
- 'namespaces': d({
1580
- "G": {
1581
- 'data types': d({
1582
- }),
1583
- 'namespaces': d({
1584
- "in": {
1585
- 'data types': d({
1586
- }),
1587
- 'namespaces': d({
1588
- }),
1589
- },
1590
- "out": {
1591
- 'data types': d({
1592
- }),
1593
- 'namespaces': d({
1594
- }),
1595
- },
1596
- }),
1597
- },
1598
- }),
1599
- },
1600
- "interface initializer": {
1601
- 'data types': d({
1602
- }),
1603
- 'namespaces': d({
1604
- "G": {
1605
- 'data types': d({
1606
- }),
1607
- 'namespaces': d({
1608
- "downstreams": {
1609
- 'data types': d({
1610
- }),
1611
- 'namespaces': d({
1612
- "DX": {
1613
- 'data types': d({
1614
- }),
1615
- 'namespaces': d({
1616
- }),
1617
- },
1618
- }),
1619
- },
1620
- "interface": {
1621
- 'data types': d({
1622
- }),
1623
- 'namespaces': d({
1624
- }),
1625
- },
1626
- }),
1627
- },
1628
- }),
1629
- },
1630
- "procedure": {
1631
- 'data types': d({
1632
- }),
1633
- 'namespaces': d({
1634
- "G": {
1635
- 'data types': d({
1636
- }),
1637
- 'namespaces': d({
1638
- "in": {
1639
- 'data types': d({
1640
- }),
1641
- 'namespaces': d({
1642
- }),
1643
- },
1644
- "out": {
1645
- 'data types': d({
1646
- }),
1647
- 'namespaces': d({
1648
- }),
1649
- },
1650
- }),
1651
- },
1652
- }),
1653
- },
1654
- "resource initializer": {
1655
- 'data types': d({
1656
- }),
1657
- 'namespaces': d({
1658
- "G": {
1659
- 'data types': d({
1660
- }),
1661
- 'namespaces': d({
1662
- "consumer": {
1663
- 'data types': d({
1664
- }),
1665
- 'namespaces': d({
1666
- }),
1667
- },
1668
- "request": {
1669
- 'data types': d({
1670
- }),
1671
- 'namespaces': d({
1672
- }),
1673
- },
1674
- }),
1675
- },
1676
- }),
1677
- },
1678
- "synchronous function": {
1679
- 'data types': d({
1680
- }),
1681
- 'namespaces': d({
1682
- "G": {
1683
- 'data types': d({
1684
- }),
1685
- 'namespaces': d({
1686
- "in": {
1687
- 'data types': d({
1688
- }),
1689
- 'namespaces': d({
1690
- }),
1691
- },
1692
- "out": {
1693
- 'data types': d({
1694
- }),
1695
- 'namespaces': d({
1696
- }),
1697
- },
1698
- }),
1699
- },
1700
- }),
1701
- },
1702
- }),
1703
- },
1704
- }),
1705
- },
1706
- }),
1707
- },
1708
- }),
1709
- },
1710
- }),
1711
- },
1712
- "data glossary": {
1713
- 'data types': d({
1714
- }),
1715
- 'namespaces': d({
1716
- }),
1717
- },
1718
- "interface types": {
1719
- 'data types': d({
1720
- }),
1721
- 'namespaces': d({
1722
- "DX": {
1723
- 'data types': d({
1724
- }),
1725
- 'namespaces': d({
1726
- "G": {
1727
- 'data types': d({
1728
- }),
1729
- 'namespaces': d({
1730
- "parameters": {
1731
- 'data types': d({
1732
- }),
1733
- 'namespaces': d({
1734
- }),
1735
- },
1736
- "type": {
1737
- 'data types': d({
1738
- }),
1739
- 'namespaces': d({
1740
- "TU": {
1741
- 'data types': d({
1742
- }),
1743
- 'namespaces': d({
1744
- "asynchronous": {
1745
- 'data types': d({
1746
- }),
1747
- 'namespaces': d({
1748
- "G": {
1749
- 'data types': d({
1750
- }),
1751
- 'namespaces': d({
1752
- "interface": {
1753
- 'data types': d({
1754
- }),
1755
- 'namespaces': d({
1756
- }),
1757
- },
1758
- }),
1759
- },
1760
- }),
1761
- },
1762
- "synchronous": {
1763
- 'data types': d({
1764
- }),
1765
- 'namespaces': d({
1766
- "G": {
1767
- 'data types': d({
1768
- }),
1769
- 'namespaces': d({
1770
- "interface": {
1771
- 'data types': d({
1772
- }),
1773
- 'namespaces': d({
1774
- }),
1775
- },
1776
- }),
1777
- },
1778
- }),
1779
- },
1780
- }),
1781
- },
1782
- }),
1783
- },
1784
- }),
1785
- },
1786
- }),
1787
- },
1788
- }),
1789
- },
1790
- }),
1791
- },
1792
- }),
1793
- },
1794
- "Glossary Reference": {
1795
- 'data types': d({
1796
- }),
1797
- 'namespaces': d({
1798
- "G": {
1799
- 'data types': d({
1800
- }),
1801
- 'namespaces': d({
1802
- "glossary": {
1803
- 'data types': d({
1804
- }),
1805
- 'namespaces': d({
1806
- }),
1807
- },
1808
- }),
1809
- },
1810
- }),
1811
- },
1812
- "Library": {
1813
- 'data types': d({
1814
- }),
1815
- 'namespaces': d({
1816
- "G": {
1817
- 'data types': d({
1818
- }),
1819
- 'namespaces': d({
1820
- "author": {
1821
- 'data types': d({
1822
- }),
1823
- 'namespaces': d({
1824
- }),
1825
- },
1826
- "description": {
1827
- 'data types': d({
1828
- }),
1829
- 'namespaces': d({
1830
- }),
1831
- },
1832
- "license": {
1833
- 'data types': d({
1834
- }),
1835
- 'namespaces': d({
1836
- }),
1837
- },
1838
- "module sets": {
1839
- 'data types': d({
1840
- }),
1841
- 'namespaces': d({
1842
- "G": {
1843
- 'data types': d({
1844
- }),
1845
- 'namespaces': d({
1846
- "private": {
1847
- 'data types': d({
1848
- }),
1849
- 'namespaces': d({
1850
- }),
1851
- },
1852
- "public": {
1853
- 'data types': d({
1854
- }),
1855
- 'namespaces': d({
1856
- }),
1857
- },
1858
- }),
1859
- },
1860
- }),
1861
- },
1862
- "type": {
1863
- 'data types': d({
1864
- }),
1865
- 'namespaces': d({
1866
- "TU": {
1867
- 'data types': d({
1868
- }),
1869
- 'namespaces': d({
1870
- "composite": {
1871
- 'data types': d({
1872
- }),
1873
- 'namespaces': d({
1874
- "G": {
1875
- 'data types': d({
1876
- }),
1877
- 'namespaces': d({
1878
- "dependencies": {
1879
- 'data types': d({
1880
- }),
1881
- 'namespaces': d({
1882
- "DX": {
1883
- 'data types': d({
1884
- }),
1885
- 'namespaces': d({
1886
- "G": {
1887
- 'data types': d({
1888
- }),
1889
- 'namespaces': d({
1890
- "library": {
1891
- 'data types': d({
1892
- }),
1893
- 'namespaces': d({
1894
- }),
1895
- },
1896
- "version": {
1897
- 'data types': d({
1898
- }),
1899
- 'namespaces': d({
1900
- }),
1901
- },
1902
- }),
1903
- },
1904
- }),
1905
- },
1906
- }),
1907
- },
1908
- "pure": {
1909
- 'data types': d({
1910
- }),
1911
- 'namespaces': d({
1912
- }),
1913
- },
1914
- }),
1915
- },
1916
- }),
1917
- },
1918
- "primitive": {
1919
- 'data types': d({
1920
- }),
1921
- 'namespaces': d({
1922
- "G": {
1923
- 'data types': d({
1924
- }),
1925
- 'namespaces': d({
1926
- }),
1927
- },
1928
- }),
1929
- },
1930
- }),
1931
- },
1932
- }),
1933
- },
1934
- }),
1935
- },
1936
- }),
1937
- },
1938
- "Module Set": {
1939
- 'data types': d({
1940
- }),
1941
- 'namespaces': d({
1942
- "G": {
1943
- 'data types': d({
1944
- }),
1945
- 'namespaces': d({
1946
- "glossaries": {
1947
- 'data types': d({
1948
- }),
1949
- 'namespaces': d({
1950
- "DX": {
1951
- 'data types': d({
1952
- }),
1953
- 'namespaces': d({
1954
- "G": {
1955
- 'data types': d({
1956
- }),
1957
- 'namespaces': d({
1958
- "description": {
1959
- 'data types': d({
1960
- }),
1961
- 'namespaces': d({
1962
- }),
1963
- },
1964
- "glossary": {
1965
- 'data types': d({
1966
- }),
1967
- 'namespaces': d({
1968
- }),
1969
- },
1970
- }),
1971
- },
1972
- }),
1973
- },
1974
- }),
1975
- },
1976
- "modules": {
1977
- 'data types': d({
1978
- }),
1979
- 'namespaces': d({
1980
- "DX": {
1981
- 'data types': d({
1982
- }),
1983
- 'namespaces': d({
1984
- }),
1985
- },
1986
- }),
1987
- },
1988
- "transformations": {
1989
- 'data types': d({
1990
- }),
1991
- 'namespaces': d({
1992
- "G": {
1993
- 'data types': d({
1994
- }),
1995
- 'namespaces': d({
1996
- "enrich": {
1997
- 'data types': d({
1998
- }),
1999
- 'namespaces': d({
2000
- "DX": {
2001
- 'data types': d({
2002
- }),
2003
- 'namespaces': d({
2004
- }),
2005
- },
2006
- }),
2007
- },
2008
- "yield": {
2009
- 'data types': d({
2010
- }),
2011
- 'namespaces': d({
2012
- "DX": {
2013
- 'data types': d({
2014
- }),
2015
- 'namespaces': d({
2016
- }),
2017
- },
2018
- }),
2019
- },
2020
- }),
2021
- },
2022
- }),
2023
- },
2024
- }),
2025
- },
2026
- }),
2027
- },
2028
- "Namespace": {
2029
- 'data types': d({
2030
- }),
2031
- 'namespaces': d({
2032
- "G": {
2033
- 'data types': d({
2034
- }),
2035
- 'namespaces': d({
2036
- "data types": {
2037
- 'data types': d({
2038
- }),
2039
- 'namespaces': d({
2040
- "DX": {
2041
- 'data types': d({
2042
- }),
2043
- 'namespaces': d({
2044
- "G": {
2045
- 'data types': d({
2046
- }),
2047
- 'namespaces': d({
2048
- "parameters": {
2049
- 'data types': d({
2050
- }),
2051
- 'namespaces': d({
2052
- }),
2053
- },
2054
- "type": {
2055
- 'data types': d({
2056
- }),
2057
- 'namespaces': d({
2058
- }),
2059
- },
2060
- }),
2061
- },
2062
- }),
2063
- },
2064
- }),
2065
- },
2066
- "namespaces": {
2067
- 'data types': d({
2068
- }),
2069
- 'namespaces': d({
2070
- "DX": {
2071
- 'data types': d({
2072
- }),
2073
- 'namespaces': d({
2074
- }),
2075
- },
2076
- }),
2077
- },
2078
- }),
2079
- },
2080
- }),
2081
- },
2082
- "Parameters": {
2083
- 'data types': d({
2084
- }),
2085
- 'namespaces': d({
2086
- "DX": {
2087
- 'data types': d({
2088
- }),
2089
- 'namespaces': d({
2090
- }),
2091
- },
2092
- }),
2093
- },
2094
- "Synchronous Interface Reference": {
2095
- 'data types': d({
2096
- }),
2097
- 'namespaces': d({
2098
- "G": {
2099
- 'data types': d({
2100
- }),
2101
- 'namespaces': d({
2102
- "context": {
2103
- 'data types': d({
2104
- }),
2105
- 'namespaces': d({
2106
- "TU": {
2107
- 'data types': d({
2108
- }),
2109
- 'namespaces': d({
2110
- "import": {
2111
- 'data types': d({
2112
- }),
2113
- 'namespaces': d({
2114
- "G": {
2115
- 'data types': d({
2116
- }),
2117
- 'namespaces': d({
2118
- "glossary": {
2119
- 'data types': d({
2120
- }),
2121
- 'namespaces': d({
2122
- }),
2123
- },
2124
- "interfaceXX": {
2125
- 'data types': d({
2126
- }),
2127
- 'namespaces': d({
2128
- }),
2129
- },
2130
- }),
2131
- },
2132
- }),
2133
- },
2134
- "local": {
2135
- 'data types': d({
2136
- }),
2137
- 'namespaces': d({
2138
- "G": {
2139
- 'data types': d({
2140
- }),
2141
- 'namespaces': d({
2142
- "interfaceXX": {
2143
- 'data types': d({
2144
- }),
2145
- 'namespaces': d({
2146
- }),
2147
- },
2148
- }),
2149
- },
2150
- }),
2151
- },
2152
- }),
2153
- },
2154
- }),
2155
- },
2156
- "type arguments": {
2157
- 'data types': d({
2158
- }),
2159
- 'namespaces': d({
2160
- }),
2161
- },
2162
- }),
2163
- },
2164
- }),
2165
- },
2166
- "Synchronous Interface Type": {
2167
- 'data types': d({
2168
- }),
2169
- 'namespaces': d({
2170
- "TU": {
2171
- 'data types': d({
2172
- }),
2173
- 'namespaces': d({
2174
- "group": {
2175
- 'data types': d({
2176
- }),
2177
- 'namespaces': d({
2178
- "G": {
2179
- 'data types': d({
2180
- }),
2181
- 'namespaces': d({
2182
- "members": {
2183
- 'data types': d({
2184
- }),
2185
- 'namespaces': d({
2186
- "DX": {
2187
- 'data types': d({
2188
- }),
2189
- 'namespaces': d({
2190
- }),
2191
- },
2192
- }),
2193
- },
2194
- }),
2195
- },
2196
- }),
2197
- },
2198
- "method": {
2199
- 'data types': d({
2200
- }),
2201
- 'namespaces': d({
2202
- "G": {
2203
- 'data types': d({
2204
- }),
2205
- 'namespaces': d({
2206
- "data": {
2207
- 'data types': d({
2208
- }),
2209
- 'namespaces': d({
2210
- "O": {
2211
- 'data types': d({
2212
- }),
2213
- 'namespaces': d({
2214
- }),
2215
- },
2216
- }),
2217
- },
2218
- "interface": {
2219
- 'data types': d({
2220
- }),
2221
- 'namespaces': d({
2222
- "O": {
2223
- 'data types': d({
2224
- }),
2225
- 'namespaces': d({
2226
- }),
2227
- },
2228
- }),
2229
- },
2230
- }),
2231
- },
2232
- }),
2233
- },
2234
- "reference": {
2235
- 'data types': d({
2236
- }),
2237
- 'namespaces': d({
2238
- }),
2239
- },
2240
- }),
2241
- },
2242
- }),
2243
- },
2244
- "Transformation": {
2245
- 'data types': d({
2246
- }),
2247
- 'namespaces': d({
2248
- "G": {
2249
- 'data types': d({
2250
- }),
2251
- 'namespaces': d({
2252
- "parameters": {
2253
- 'data types': d({
2254
- }),
2255
- 'namespaces': d({
2256
- "DX": {
2257
- 'data types': d({
2258
- }),
2259
- 'namespaces': d({
2260
- }),
2261
- },
2262
- }),
2263
- },
2264
- }),
2265
- },
2266
- }),
2267
- },
2268
- "Transformations": {
2269
- 'data types': d({
2270
- }),
2271
- 'namespaces': d({
2272
- "G": {
2273
- 'data types': d({
2274
- }),
2275
- 'namespaces': d({
2276
- "atom": {
2277
- 'data types': d({
2278
- }),
2279
- 'namespaces': d({
2280
- "G": {
2281
- 'data types': d({
2282
- }),
2283
- 'namespaces': d({
2284
- "boolean": {
2285
- 'data types': d({
2286
- }),
2287
- 'namespaces': d({
2288
- "DX": {
2289
- 'data types': d({
2290
- }),
2291
- 'namespaces': d({
2292
- }),
2293
- },
2294
- }),
2295
- },
2296
- "dictionary": {
2297
- 'data types': d({
2298
- }),
2299
- 'namespaces': d({
2300
- "DX": {
2301
- 'data types': d({
2302
- }),
2303
- 'namespaces': d({
2304
- }),
2305
- },
2306
- }),
2307
- },
2308
- "integer": {
2309
- 'data types': d({
2310
- }),
2311
- 'namespaces': d({
2312
- "DX": {
2313
- 'data types': d({
2314
- }),
2315
- 'namespaces': d({
2316
- }),
2317
- },
2318
- }),
2319
- },
2320
- "list": {
2321
- 'data types': d({
2322
- }),
2323
- 'namespaces': d({
2324
- "DX": {
2325
- 'data types': d({
2326
- }),
2327
- 'namespaces': d({
2328
- }),
2329
- },
2330
- }),
2331
- },
2332
- "text": {
2333
- 'data types': d({
2334
- }),
2335
- 'namespaces': d({
2336
- "DX": {
2337
- 'data types': d({
2338
- }),
2339
- 'namespaces': d({
2340
- }),
2341
- },
2342
- }),
2343
- },
2344
- }),
2345
- },
2346
- }),
2347
- },
2348
- "composite": {
2349
- 'data types': d({
2350
- }),
2351
- 'namespaces': d({
2352
- "G": {
2353
- 'data types': d({
2354
- }),
2355
- 'namespaces': d({
2356
- "external libraries": {
2357
- 'data types': d({
2358
- }),
2359
- 'namespaces': d({
2360
- "DX": {
2361
- 'data types': d({
2362
- }),
2363
- 'namespaces': d({
2364
- }),
2365
- },
2366
- }),
2367
- },
2368
- "local": {
2369
- 'data types': d({
2370
- }),
2371
- 'namespaces': d({
2372
- }),
2373
- },
2374
- }),
2375
- },
2376
- }),
2377
- },
2378
- "glossary": {
2379
- 'data types': d({
2380
- }),
2381
- 'namespaces': d({
2382
- }),
2383
- },
2384
- }),
2385
- },
2386
- }),
2387
- },
2388
- }),
2389
- },
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
+ }),
11
+ 'imports': d({
12
+ }),
13
+ 'root': {
14
+ 'data types': d({
15
+ "API": {
16
+ 'parameters': d({
17
+ }),
18
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
19
+ "algorithms": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
20
+ "definition": ['component', ['type', {
21
+ 'context': ['local', null],
22
+ 'tailXX': a([
23
+ ]),
24
+ 'type arguments': d({
25
+ }),
26
+ 'typeXX': "Algorithm Type Reference",
27
+ }]],
28
+ "dependencies": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
29
+ "algorithm type": ['component', ['type', {
30
+ 'context': ['local', null],
31
+ 'tailXX': a([
32
+ ]),
33
+ 'type arguments': d({
34
+ }),
35
+ 'typeXX': "Algorithm Type Reference",
36
+ }]],
37
+ "module": ['text', null],
38
+ "type": ['state group', d({
39
+ "library dependency": ['text', null],
40
+ "private": ['nothing', null],
41
+ "public": ['nothing', null],
42
+ "sibling": ['nothing', null],
43
+ })],
44
+ "type arguments": ['dictionary', ['state group', d({
45
+ "api parameter": ['text', null],
46
+ "data type": ['text', null],
47
+ })]],
48
+ })]],
49
+ })]],
50
+ "provided interface": ['component', ['type', {
51
+ 'context': ['local', null],
52
+ 'tailXX': a([
53
+ ]),
54
+ 'type arguments': d({
55
+ }),
56
+ 'typeXX': "Glossary",
57
+ }]],
58
+ })],
59
+ },
60
+ "Algorithm Type Reference": {
61
+ 'parameters': d({
62
+ }),
63
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
64
+ "algorithm type": ['text', null],
65
+ })],
66
+ },
67
+ "Arguments": {
68
+ 'parameters': d({
69
+ }),
70
+ 'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
71
+ "content": ['component', ['type', {
72
+ 'context': ['local', null],
73
+ 'tailXX': a([
74
+ ]),
75
+ 'type arguments': d({
76
+ }),
77
+ 'typeXX': "Data Type Specifier",
78
+ }]],
79
+ })]],
80
+ },
81
+ "Asynchronous Interface Reference": {
82
+ 'parameters': d({
83
+ }),
84
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
85
+ "context": ['state group', d({
86
+ "import": ['group', d<g_cosmos.D.Data__Type>({
87
+ "glossary": ['component', ['type', {
88
+ 'context': ['local', null],
89
+ 'tailXX': a([
90
+ ]),
91
+ 'type arguments': d({
92
+ }),
93
+ 'typeXX': "Glossary Reference",
94
+ }]],
95
+ })],
96
+ "local": ['nothing', null],
97
+ })],
98
+ "interfaceXX": ['text', null],
99
+ "type arguments": ['component', ['type', {
100
+ 'context': ['local', null],
101
+ 'tailXX': a([
102
+ ]),
103
+ 'type arguments': d({
104
+ }),
105
+ 'typeXX': "Arguments",
106
+ }]],
107
+ })],
108
+ },
109
+ "Asynchronous Interface Type": {
110
+ 'parameters': d({
111
+ }),
112
+ 'type': ['state group', d({
113
+ "choice": ['group', d<g_cosmos.D.Data__Type>({
114
+ "options": ['dictionary', ['component', ['type', {
115
+ 'context': ['local', null],
116
+ 'tailXX': a([
117
+ ]),
118
+ 'type arguments': d({
119
+ }),
120
+ 'typeXX': "Asynchronous Interface Type",
121
+ }]]],
122
+ })],
123
+ "method": ['group', d<g_cosmos.D.Data__Type>({
124
+ "data": ['optional', ['component', ['type', {
125
+ 'context': ['local', null],
126
+ 'tailXX': a([
127
+ ]),
128
+ 'type arguments': d({
129
+ }),
130
+ 'typeXX': "Data Type Specifier",
131
+ }]]],
132
+ "interface": ['optional', ['component', ['type', {
133
+ 'context': ['local', null],
134
+ 'tailXX': a([
135
+ ]),
136
+ 'type arguments': d({
137
+ }),
138
+ 'typeXX': "Asynchronous Interface Type",
139
+ }]]],
140
+ })],
141
+ "reference": ['component', ['type', {
142
+ 'context': ['local', null],
143
+ 'tailXX': a([
144
+ ]),
145
+ 'type arguments': d({
146
+ }),
147
+ 'typeXX': "Asynchronous Interface Reference",
148
+ }]],
149
+ "streamconsumer": ['group', d<g_cosmos.D.Data__Type>({
150
+ "data": ['component', ['type', {
151
+ 'context': ['local', null],
152
+ 'tailXX': a([
153
+ ]),
154
+ 'type arguments': d({
155
+ }),
156
+ 'typeXX': "Asynchronous Interface Type",
157
+ }]],
158
+ "end": ['optional', ['component', ['type', {
159
+ 'context': ['local', null],
160
+ 'tailXX': a([
161
+ ]),
162
+ 'type arguments': d({
163
+ }),
164
+ 'typeXX': "Asynchronous Interface Type",
165
+ }]]],
166
+ })],
167
+ })],
168
+ },
169
+ "Composite Transformations": {
170
+ 'parameters': d({
171
+ }),
172
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
173
+ "higher glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
174
+ "types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
175
+ "lower glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
176
+ "target types": ['dictionary', ['component', ['type', {
177
+ 'context': ['local', null],
178
+ 'tailXX': a([
179
+ ]),
180
+ 'type arguments': d({
181
+ }),
182
+ 'typeXX': "Transformation",
183
+ }]]],
184
+ })]],
185
+ })]],
186
+ })]],
187
+ })],
188
+ },
189
+ "Data Glossary": {
190
+ 'parameters': d({
191
+ }),
192
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
193
+ "glossary parameters": ['component', ['type', {
194
+ 'context': ['local', null],
195
+ 'tailXX': a([
196
+ ]),
197
+ 'type arguments': d({
198
+ }),
199
+ 'typeXX': "Parameters",
200
+ }]],
201
+ "imports": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
202
+ "glossary": ['component', ['type', {
203
+ 'context': ['local', null],
204
+ 'tailXX': a([
205
+ ]),
206
+ 'type arguments': d({
207
+ }),
208
+ 'typeXX': "Data Glossary",
209
+ }]],
210
+ "type arguments": ['component', ['type', {
211
+ 'context': ['local', null],
212
+ 'tailXX': a([
213
+ ]),
214
+ 'type arguments': d({
215
+ }),
216
+ 'typeXX': "Arguments",
217
+ }]],
218
+ })]],
219
+ "root": ['component', ['type', {
220
+ 'context': ['local', null],
221
+ 'tailXX': a([
222
+ ]),
223
+ 'type arguments': d({
224
+ }),
225
+ 'typeXX': "Namespace",
226
+ }]],
227
+ })],
228
+ },
229
+ "Data Or Synchronous Interface": {
230
+ 'parameters': d({
231
+ }),
232
+ 'type': ['state group', d({
233
+ "data": ['component', ['type', {
234
+ 'context': ['local', null],
235
+ 'tailXX': a([
236
+ ]),
237
+ 'type arguments': d({
238
+ }),
239
+ 'typeXX': "Data Type Specifier",
240
+ }]],
241
+ "interface": ['component', ['type', {
242
+ 'context': ['local', null],
243
+ 'tailXX': a([
244
+ ]),
245
+ 'type arguments': d({
246
+ }),
247
+ 'typeXX': "Synchronous Interface Reference",
248
+ }]],
249
+ })],
250
+ },
251
+ "Data Type": {
252
+ 'parameters': d({
253
+ }),
254
+ 'type': ['state group', d({
255
+ "boolean": ['nothing', null],
256
+ "component": ['component', ['type', {
257
+ 'context': ['local', null],
258
+ 'tailXX': a([
259
+ ]),
260
+ 'type arguments': d({
261
+ }),
262
+ 'typeXX': "Data Type Specifier",
263
+ }]],
264
+ "dictionary": ['component', ['type', {
265
+ 'context': ['local', null],
266
+ 'tailXX': a([
267
+ ]),
268
+ 'type arguments': d({
269
+ }),
270
+ 'typeXX': "Data Type",
271
+ }]],
272
+ "group": ['dictionary', ['component', ['type', {
273
+ 'context': ['local', null],
274
+ 'tailXX': a([
275
+ ]),
276
+ 'type arguments': d({
277
+ }),
278
+ 'typeXX': "Data Type",
279
+ }]]],
280
+ "integer": ['nothing', null],
281
+ "link": ['group', d<g_cosmos.D.Data__Type>({
282
+ "forward": ['boolean', null],
283
+ "target": ['component', ['type', {
284
+ 'context': ['local', null],
285
+ 'tailXX': a([
286
+ ]),
287
+ 'type arguments': d({
288
+ }),
289
+ 'typeXX': "Data Type Specifier",
290
+ }]],
291
+ "value": ['component', ['type', {
292
+ 'context': ['local', null],
293
+ 'tailXX': a([
294
+ ]),
295
+ 'type arguments': d({
296
+ }),
297
+ 'typeXX': "Data Type",
298
+ }]],
299
+ })],
300
+ "list": ['component', ['type', {
301
+ 'context': ['local', null],
302
+ 'tailXX': a([
303
+ ]),
304
+ 'type arguments': d({
305
+ }),
306
+ 'typeXX': "Data Type",
307
+ }]],
308
+ "nothing": ['nothing', null],
309
+ "optional": ['component', ['type', {
310
+ 'context': ['local', null],
311
+ 'tailXX': a([
312
+ ]),
313
+ 'type arguments': d({
314
+ }),
315
+ 'typeXX': "Data Type",
316
+ }]],
317
+ "state group": ['dictionary', ['component', ['type', {
318
+ 'context': ['local', null],
319
+ 'tailXX': a([
320
+ ]),
321
+ 'type arguments': d({
322
+ }),
323
+ 'typeXX': "Data Type",
324
+ }]]],
325
+ "text": ['nothing', null],
326
+ })],
327
+ },
328
+ "Data Type Reference": {
329
+ 'parameters': d({
330
+ }),
331
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
332
+ "type": ['text', null],
333
+ "type arguments": ['component', ['type', {
334
+ 'context': ['local', null],
335
+ 'tailXX': a([
336
+ ]),
337
+ 'type arguments': d({
338
+ }),
339
+ 'typeXX': "Arguments",
340
+ }]],
341
+ })],
342
+ },
343
+ "Data Type Specifier": {
344
+ 'parameters': d({
345
+ }),
346
+ 'type': ['state group', d({
347
+ "glossary parameterXX": ['text', null],
348
+ "type": ['group', d<g_cosmos.D.Data__Type>({
349
+ "context": ['state group', d({
350
+ "import": ['group', d<g_cosmos.D.Data__Type>({
351
+ "glossary": ['component', ['type', {
352
+ 'context': ['local', null],
353
+ 'tailXX': a([
354
+ ]),
355
+ 'type arguments': d({
356
+ }),
357
+ 'typeXX': "Glossary Reference",
358
+ }]],
359
+ })],
360
+ "local": ['nothing', null],
361
+ })],
362
+ "tailXX": ['list', ['text', null]],
363
+ "type arguments": ['component', ['type', {
364
+ 'context': ['local', null],
365
+ 'tailXX': a([
366
+ ]),
367
+ 'type arguments': d({
368
+ }),
369
+ 'typeXX': "Arguments",
370
+ }]],
371
+ "typeXX": ['text', null],
372
+ })],
373
+ "type parameterXX": ['text', null],
374
+ })],
375
+ },
376
+ "Glossary": {
377
+ 'parameters': d({
378
+ }),
379
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
380
+ "algorithm types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
381
+ "parameters": ['component', ['type', {
382
+ 'context': ['local', null],
383
+ 'tailXX': a([
384
+ ]),
385
+ 'type arguments': d({
386
+ }),
387
+ 'typeXX': "Parameters",
388
+ }]],
389
+ "type": ['state group', d({
390
+ "asynchronous function": ['group', d<g_cosmos.D.Data__Type>({
391
+ "in": ['component', ['type', {
392
+ 'context': ['local', null],
393
+ 'tailXX': a([
394
+ ]),
395
+ 'type arguments': d({
396
+ }),
397
+ 'typeXX': "Data Type Specifier",
398
+ }]],
399
+ "out": ['component', ['type', {
400
+ 'context': ['local', null],
401
+ 'tailXX': a([
402
+ ]),
403
+ 'type arguments': d({
404
+ }),
405
+ 'typeXX': "Data Type Specifier",
406
+ }]],
407
+ })],
408
+ "interface initializer": ['group', d<g_cosmos.D.Data__Type>({
409
+ "downstreams": ['dictionary', ['component', ['type', {
410
+ 'context': ['local', null],
411
+ 'tailXX': a([
412
+ ]),
413
+ 'type arguments': d({
414
+ }),
415
+ 'typeXX': "Asynchronous Interface Reference",
416
+ }]]],
417
+ "interface": ['component', ['type', {
418
+ 'context': ['local', null],
419
+ 'tailXX': a([
420
+ ]),
421
+ 'type arguments': d({
422
+ }),
423
+ 'typeXX': "Asynchronous Interface Reference",
424
+ }]],
425
+ })],
426
+ "procedure": ['group', d<g_cosmos.D.Data__Type>({
427
+ "in": ['component', ['type', {
428
+ 'context': ['local', null],
429
+ 'tailXX': a([
430
+ ]),
431
+ 'type arguments': d({
432
+ }),
433
+ 'typeXX': "Data Or Synchronous Interface",
434
+ }]],
435
+ "out": ['component', ['type', {
436
+ 'context': ['local', null],
437
+ 'tailXX': a([
438
+ ]),
439
+ 'type arguments': d({
440
+ }),
441
+ 'typeXX': "Synchronous Interface Reference",
442
+ }]],
443
+ })],
444
+ "resource initializer": ['group', d<g_cosmos.D.Data__Type>({
445
+ "consumer": ['component', ['type', {
446
+ 'context': ['local', null],
447
+ 'tailXX': a([
448
+ ]),
449
+ 'type arguments': d({
450
+ }),
451
+ 'typeXX': "Asynchronous Interface Reference",
452
+ }]],
453
+ "request": ['component', ['type', {
454
+ 'context': ['local', null],
455
+ 'tailXX': a([
456
+ ]),
457
+ 'type arguments': d({
458
+ }),
459
+ 'typeXX': "Data Type Specifier",
460
+ }]],
461
+ })],
462
+ "synchronous function": ['group', d<g_cosmos.D.Data__Type>({
463
+ "in": ['component', ['type', {
464
+ 'context': ['local', null],
465
+ 'tailXX': a([
466
+ ]),
467
+ 'type arguments': d({
468
+ }),
469
+ 'typeXX': "Data Or Synchronous Interface",
470
+ }]],
471
+ "out": ['component', ['type', {
472
+ 'context': ['local', null],
473
+ 'tailXX': a([
474
+ ]),
475
+ 'type arguments': d({
476
+ }),
477
+ 'typeXX': "Data Type Specifier",
478
+ }]],
479
+ })],
480
+ })],
481
+ })]],
482
+ "data glossary": ['component', ['type', {
483
+ 'context': ['local', null],
484
+ 'tailXX': a([
485
+ ]),
486
+ 'type arguments': d({
487
+ }),
488
+ 'typeXX': "Data Glossary",
489
+ }]],
490
+ "interface types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
491
+ "parameters": ['component', ['type', {
492
+ 'context': ['local', null],
493
+ 'tailXX': a([
494
+ ]),
495
+ 'type arguments': d({
496
+ }),
497
+ 'typeXX': "Parameters",
498
+ }]],
499
+ "type": ['state group', d({
500
+ "asynchronous": ['group', d<g_cosmos.D.Data__Type>({
501
+ "interface": ['component', ['type', {
502
+ 'context': ['local', null],
503
+ 'tailXX': a([
504
+ ]),
505
+ 'type arguments': d({
506
+ }),
507
+ 'typeXX': "Asynchronous Interface Type",
508
+ }]],
509
+ })],
510
+ "synchronous": ['group', d<g_cosmos.D.Data__Type>({
511
+ "interface": ['component', ['type', {
512
+ 'context': ['local', null],
513
+ 'tailXX': a([
514
+ ]),
515
+ 'type arguments': d({
516
+ }),
517
+ 'typeXX': "Synchronous Interface Type",
518
+ }]],
519
+ })],
520
+ })],
521
+ })]],
522
+ })],
523
+ },
524
+ "Glossary Reference": {
525
+ 'parameters': d({
526
+ }),
527
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
528
+ "glossary": ['text', null],
529
+ })],
530
+ },
531
+ "Library": {
532
+ 'parameters': d({
533
+ }),
534
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
535
+ "author": ['text', null],
536
+ "description": ['text', null],
537
+ "license": ['text', null],
538
+ "module sets": ['group', d<g_cosmos.D.Data__Type>({
539
+ "private": ['component', ['type', {
540
+ 'context': ['local', null],
541
+ 'tailXX': a([
542
+ ]),
543
+ 'type arguments': d({
544
+ }),
545
+ 'typeXX': "Module Set",
546
+ }]],
547
+ "public": ['component', ['type', {
548
+ 'context': ['local', null],
549
+ 'tailXX': a([
550
+ ]),
551
+ 'type arguments': d({
552
+ }),
553
+ 'typeXX': "Module Set",
554
+ }]],
555
+ })],
556
+ "type": ['state group', d({
557
+ "composite": ['group', d<g_cosmos.D.Data__Type>({
558
+ "dependencies": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
559
+ "library": ['component', ['type', {
560
+ 'context': ['local', null],
561
+ 'tailXX': a([
562
+ ]),
563
+ 'type arguments': d({
564
+ }),
565
+ 'typeXX': "Library",
566
+ }]],
567
+ "version": ['text', null],
568
+ })]],
569
+ "pure": ['boolean', null],
570
+ })],
571
+ "primitive": ['group', d<g_cosmos.D.Data__Type>({
572
+ })],
573
+ })],
574
+ })],
575
+ },
576
+ "Module Set": {
577
+ 'parameters': d({
578
+ }),
579
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
580
+ "glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
581
+ "description": ['text', null],
582
+ "glossary": ['component', ['type', {
583
+ 'context': ['local', null],
584
+ 'tailXX': a([
585
+ ]),
586
+ 'type arguments': d({
587
+ }),
588
+ 'typeXX': "Data Glossary",
589
+ }]],
590
+ })]],
591
+ "modules": ['dictionary', ['component', ['type', {
592
+ 'context': ['local', null],
593
+ 'tailXX': a([
594
+ ]),
595
+ 'type arguments': d({
596
+ }),
597
+ 'typeXX': "API",
598
+ }]]],
599
+ "transformations": ['group', d<g_cosmos.D.Data__Type>({
600
+ "enrich": ['dictionary', ['component', ['type', {
601
+ 'context': ['local', null],
602
+ 'tailXX': a([
603
+ ]),
604
+ 'type arguments': d({
605
+ }),
606
+ 'typeXX': "Transformations",
607
+ }]]],
608
+ "yield": ['dictionary', ['component', ['type', {
609
+ 'context': ['local', null],
610
+ 'tailXX': a([
611
+ ]),
612
+ 'type arguments': d({
613
+ }),
614
+ 'typeXX': "Transformations",
615
+ }]]],
616
+ })],
617
+ })],
618
+ },
619
+ "Namespace": {
620
+ 'parameters': d({
621
+ }),
622
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
623
+ "data types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
624
+ "parameters": ['component', ['type', {
625
+ 'context': ['local', null],
626
+ 'tailXX': a([
627
+ ]),
628
+ 'type arguments': d({
629
+ }),
630
+ 'typeXX': "Parameters",
631
+ }]],
632
+ "type": ['component', ['type', {
633
+ 'context': ['local', null],
634
+ 'tailXX': a([
635
+ ]),
636
+ 'type arguments': d({
637
+ }),
638
+ 'typeXX': "Data Type",
639
+ }]],
640
+ })]],
641
+ "namespaces": ['dictionary', ['component', ['type', {
642
+ 'context': ['local', null],
643
+ 'tailXX': a([
644
+ ]),
645
+ 'type arguments': d({
646
+ }),
647
+ 'typeXX': "Namespace",
648
+ }]]],
649
+ })],
650
+ },
651
+ "Parameters": {
652
+ 'parameters': d({
653
+ }),
654
+ 'type': ['dictionary', ['nothing', null]],
655
+ },
656
+ "Synchronous Interface Reference": {
657
+ 'parameters': d({
658
+ }),
659
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
660
+ "context": ['state group', d({
661
+ "import": ['group', d<g_cosmos.D.Data__Type>({
662
+ "glossary": ['component', ['type', {
663
+ 'context': ['local', null],
664
+ 'tailXX': a([
665
+ ]),
666
+ 'type arguments': d({
667
+ }),
668
+ 'typeXX': "Glossary Reference",
669
+ }]],
670
+ "interfaceXX": ['text', null],
671
+ })],
672
+ "local": ['group', d<g_cosmos.D.Data__Type>({
673
+ "interfaceXX": ['text', null],
674
+ })],
675
+ })],
676
+ "type arguments": ['component', ['type', {
677
+ 'context': ['local', null],
678
+ 'tailXX': a([
679
+ ]),
680
+ 'type arguments': d({
681
+ }),
682
+ 'typeXX': "Arguments",
683
+ }]],
684
+ })],
685
+ },
686
+ "Synchronous Interface Type": {
687
+ 'parameters': d({
688
+ }),
689
+ 'type': ['state group', d({
690
+ "group": ['group', d<g_cosmos.D.Data__Type>({
691
+ "members": ['dictionary', ['component', ['type', {
692
+ 'context': ['local', null],
693
+ 'tailXX': a([
694
+ ]),
695
+ 'type arguments': d({
696
+ }),
697
+ 'typeXX': "Synchronous Interface Type",
698
+ }]]],
699
+ })],
700
+ "method": ['group', d<g_cosmos.D.Data__Type>({
701
+ "data": ['optional', ['component', ['type', {
702
+ 'context': ['local', null],
703
+ 'tailXX': a([
704
+ ]),
705
+ 'type arguments': d({
706
+ }),
707
+ 'typeXX': "Data Type Specifier",
708
+ }]]],
709
+ "interface": ['optional', ['component', ['type', {
710
+ 'context': ['local', null],
711
+ 'tailXX': a([
712
+ ]),
713
+ 'type arguments': d({
714
+ }),
715
+ 'typeXX': "Synchronous Interface Type",
716
+ }]]],
717
+ })],
718
+ "reference": ['component', ['type', {
719
+ 'context': ['local', null],
720
+ 'tailXX': a([
721
+ ]),
722
+ 'type arguments': d({
723
+ }),
724
+ 'typeXX': "Synchronous Interface Reference",
725
+ }]],
726
+ })],
727
+ },
728
+ "Transformation": {
729
+ 'parameters': d({
730
+ }),
731
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
732
+ "parameters": ['dictionary', ['component', ['type', {
733
+ 'context': ['local', null],
734
+ 'tailXX': a([
735
+ ]),
736
+ 'type arguments': d({
737
+ }),
738
+ 'typeXX': "Data Type Reference",
739
+ }]]],
740
+ })],
741
+ },
742
+ "Transformations": {
743
+ 'parameters': d({
744
+ }),
745
+ 'type': ['group', d<g_cosmos.D.Data__Type>({
746
+ "atom": ['group', d<g_cosmos.D.Data__Type>({
747
+ "boolean": ['dictionary', ['component', ['type', {
748
+ 'context': ['local', null],
749
+ 'tailXX': a([
750
+ ]),
751
+ 'type arguments': d({
752
+ }),
753
+ 'typeXX': "Transformation",
754
+ }]]],
755
+ "dictionary": ['dictionary', ['component', ['type', {
756
+ 'context': ['local', null],
757
+ 'tailXX': a([
758
+ ]),
759
+ 'type arguments': d({
760
+ }),
761
+ 'typeXX': "Transformation",
762
+ }]]],
763
+ "integer": ['dictionary', ['component', ['type', {
764
+ 'context': ['local', null],
765
+ 'tailXX': a([
766
+ ]),
767
+ 'type arguments': d({
768
+ }),
769
+ 'typeXX': "Transformation",
770
+ }]]],
771
+ "list": ['dictionary', ['component', ['type', {
772
+ 'context': ['local', null],
773
+ 'tailXX': a([
774
+ ]),
775
+ 'type arguments': d({
776
+ }),
777
+ 'typeXX': "Transformation",
778
+ }]]],
779
+ "text": ['dictionary', ['component', ['type', {
780
+ 'context': ['local', null],
781
+ 'tailXX': a([
782
+ ]),
783
+ 'type arguments': d({
784
+ }),
785
+ 'typeXX': "Transformation",
786
+ }]]],
787
+ })],
788
+ "composite": ['group', d<g_cosmos.D.Data__Type>({
789
+ "external libraries": ['dictionary', ['component', ['type', {
790
+ 'context': ['local', null],
791
+ 'tailXX': a([
792
+ ]),
793
+ 'type arguments': d({
794
+ }),
795
+ 'typeXX': "Composite Transformations",
796
+ }]]],
797
+ "local": ['component', ['type', {
798
+ 'context': ['local', null],
799
+ 'tailXX': a([
800
+ ]),
801
+ 'type arguments': d({
802
+ }),
803
+ 'typeXX': "Composite Transformations",
804
+ }]],
805
+ })],
806
+ "glossary": ['component', ['type', {
807
+ 'context': ['local', null],
808
+ 'tailXX': a([
809
+ ]),
810
+ 'type arguments': d({
811
+ }),
812
+ 'typeXX': "Data Glossary",
813
+ }]],
814
+ })],
815
+ },
816
+ }),
817
+ 'namespaces': d({
818
+ "API": {
819
+ 'data types': d({
820
+ }),
821
+ 'namespaces': d({
822
+ "G": {
823
+ 'data types': d({
824
+ }),
825
+ 'namespaces': d({
826
+ "algorithms": {
827
+ 'data types': d({
828
+ }),
829
+ 'namespaces': d({
830
+ "DX": {
831
+ 'data types': d({
832
+ }),
833
+ 'namespaces': d({
834
+ "G": {
835
+ 'data types': d({
836
+ }),
837
+ 'namespaces': d({
838
+ "definition": {
839
+ 'data types': d({
840
+ }),
841
+ 'namespaces': d({
842
+ }),
843
+ },
844
+ "dependencies": {
845
+ 'data types': d({
846
+ }),
847
+ 'namespaces': d({
848
+ "DX": {
849
+ 'data types': d({
850
+ }),
851
+ 'namespaces': d({
852
+ "G": {
853
+ 'data types': d({
854
+ }),
855
+ 'namespaces': d({
856
+ "algorithm type": {
857
+ 'data types': d({
858
+ }),
859
+ 'namespaces': d({
860
+ }),
861
+ },
862
+ "module": {
863
+ 'data types': d({
864
+ }),
865
+ 'namespaces': d({
866
+ }),
867
+ },
868
+ "type": {
869
+ 'data types': d({
870
+ }),
871
+ 'namespaces': d({
872
+ "TU": {
873
+ 'data types': d({
874
+ }),
875
+ 'namespaces': d({
876
+ "library dependency": {
877
+ 'data types': d({
878
+ }),
879
+ 'namespaces': d({
880
+ }),
881
+ },
882
+ "private": {
883
+ 'data types': d({
884
+ }),
885
+ 'namespaces': d({
886
+ }),
887
+ },
888
+ "public": {
889
+ 'data types': d({
890
+ }),
891
+ 'namespaces': d({
892
+ }),
893
+ },
894
+ "sibling": {
895
+ 'data types': d({
896
+ }),
897
+ 'namespaces': d({
898
+ }),
899
+ },
900
+ }),
901
+ },
902
+ }),
903
+ },
904
+ "type arguments": {
905
+ 'data types': d({
906
+ }),
907
+ 'namespaces': d({
908
+ "DX": {
909
+ 'data types': d({
910
+ }),
911
+ 'namespaces': d({
912
+ "TU": {
913
+ 'data types': d({
914
+ }),
915
+ 'namespaces': d({
916
+ "api parameter": {
917
+ 'data types': d({
918
+ }),
919
+ 'namespaces': d({
920
+ }),
921
+ },
922
+ "data type": {
923
+ 'data types': d({
924
+ }),
925
+ 'namespaces': d({
926
+ }),
927
+ },
928
+ }),
929
+ },
930
+ }),
931
+ },
932
+ }),
933
+ },
934
+ }),
935
+ },
936
+ }),
937
+ },
938
+ }),
939
+ },
940
+ }),
941
+ },
942
+ }),
943
+ },
944
+ }),
945
+ },
946
+ "provided interface": {
947
+ 'data types': d({
948
+ }),
949
+ 'namespaces': d({
950
+ }),
951
+ },
952
+ }),
953
+ },
954
+ }),
955
+ },
956
+ "Algorithm Type Reference": {
957
+ 'data types': d({
958
+ }),
959
+ 'namespaces': d({
960
+ "G": {
961
+ 'data types': d({
962
+ }),
963
+ 'namespaces': d({
964
+ "algorithm type": {
965
+ 'data types': d({
966
+ }),
967
+ 'namespaces': d({
968
+ }),
969
+ },
970
+ }),
971
+ },
972
+ }),
973
+ },
974
+ "Arguments": {
975
+ 'data types': d({
976
+ }),
977
+ 'namespaces': d({
978
+ "DX": {
979
+ 'data types': d({
980
+ }),
981
+ 'namespaces': d({
982
+ }),
983
+ },
984
+ }),
985
+ },
986
+ "Asynchronous Interface Reference": {
987
+ 'data types': d({
988
+ }),
989
+ 'namespaces': d({
990
+ "G": {
991
+ 'data types': d({
992
+ }),
993
+ 'namespaces': d({
994
+ "context": {
995
+ 'data types': d({
996
+ }),
997
+ 'namespaces': d({
998
+ "TU": {
999
+ 'data types': d({
1000
+ }),
1001
+ 'namespaces': d({
1002
+ "import": {
1003
+ 'data types': d({
1004
+ }),
1005
+ 'namespaces': d({
1006
+ "G": {
1007
+ 'data types': d({
1008
+ }),
1009
+ 'namespaces': d({
1010
+ "glossary": {
1011
+ 'data types': d({
1012
+ }),
1013
+ 'namespaces': d({
1014
+ }),
1015
+ },
1016
+ }),
1017
+ },
1018
+ }),
1019
+ },
1020
+ "local": {
1021
+ 'data types': d({
1022
+ }),
1023
+ 'namespaces': d({
1024
+ }),
1025
+ },
1026
+ }),
1027
+ },
1028
+ }),
1029
+ },
1030
+ "interfaceXX": {
1031
+ 'data types': d({
1032
+ }),
1033
+ 'namespaces': d({
1034
+ }),
1035
+ },
1036
+ "type arguments": {
1037
+ 'data types': d({
1038
+ }),
1039
+ 'namespaces': d({
1040
+ }),
1041
+ },
1042
+ }),
1043
+ },
1044
+ }),
1045
+ },
1046
+ "Asynchronous Interface Type": {
1047
+ 'data types': d({
1048
+ }),
1049
+ 'namespaces': d({
1050
+ "TU": {
1051
+ 'data types': d({
1052
+ }),
1053
+ 'namespaces': d({
1054
+ "choice": {
1055
+ 'data types': d({
1056
+ }),
1057
+ 'namespaces': d({
1058
+ "G": {
1059
+ 'data types': d({
1060
+ }),
1061
+ 'namespaces': d({
1062
+ "options": {
1063
+ 'data types': d({
1064
+ }),
1065
+ 'namespaces': d({
1066
+ "DX": {
1067
+ 'data types': d({
1068
+ }),
1069
+ 'namespaces': d({
1070
+ }),
1071
+ },
1072
+ }),
1073
+ },
1074
+ }),
1075
+ },
1076
+ }),
1077
+ },
1078
+ "method": {
1079
+ 'data types': d({
1080
+ }),
1081
+ 'namespaces': d({
1082
+ "G": {
1083
+ 'data types': d({
1084
+ }),
1085
+ 'namespaces': d({
1086
+ "data": {
1087
+ 'data types': d({
1088
+ }),
1089
+ 'namespaces': d({
1090
+ "O": {
1091
+ 'data types': d({
1092
+ }),
1093
+ 'namespaces': d({
1094
+ }),
1095
+ },
1096
+ }),
1097
+ },
1098
+ "interface": {
1099
+ 'data types': d({
1100
+ }),
1101
+ 'namespaces': d({
1102
+ "O": {
1103
+ 'data types': d({
1104
+ }),
1105
+ 'namespaces': d({
1106
+ }),
1107
+ },
1108
+ }),
1109
+ },
1110
+ }),
1111
+ },
1112
+ }),
1113
+ },
1114
+ "reference": {
1115
+ 'data types': d({
1116
+ }),
1117
+ 'namespaces': d({
1118
+ }),
1119
+ },
1120
+ "streamconsumer": {
1121
+ 'data types': d({
1122
+ }),
1123
+ 'namespaces': d({
1124
+ "G": {
1125
+ 'data types': d({
1126
+ }),
1127
+ 'namespaces': d({
1128
+ "data": {
1129
+ 'data types': d({
1130
+ }),
1131
+ 'namespaces': d({
1132
+ }),
1133
+ },
1134
+ "end": {
1135
+ 'data types': d({
1136
+ }),
1137
+ 'namespaces': d({
1138
+ "O": {
1139
+ 'data types': d({
1140
+ }),
1141
+ 'namespaces': d({
1142
+ }),
1143
+ },
1144
+ }),
1145
+ },
1146
+ }),
1147
+ },
1148
+ }),
1149
+ },
1150
+ }),
1151
+ },
1152
+ }),
1153
+ },
1154
+ "Composite Transformations": {
1155
+ 'data types': d({
1156
+ }),
1157
+ 'namespaces': d({
1158
+ "G": {
1159
+ 'data types': d({
1160
+ }),
1161
+ 'namespaces': d({
1162
+ "higher glossaries": {
1163
+ 'data types': d({
1164
+ }),
1165
+ 'namespaces': d({
1166
+ "DX": {
1167
+ 'data types': d({
1168
+ }),
1169
+ 'namespaces': d({
1170
+ "G": {
1171
+ 'data types': d({
1172
+ }),
1173
+ 'namespaces': d({
1174
+ "types": {
1175
+ 'data types': d({
1176
+ }),
1177
+ 'namespaces': d({
1178
+ "DX": {
1179
+ 'data types': d({
1180
+ }),
1181
+ 'namespaces': d({
1182
+ "G": {
1183
+ 'data types': d({
1184
+ }),
1185
+ 'namespaces': d({
1186
+ "lower glossaries": {
1187
+ 'data types': d({
1188
+ }),
1189
+ 'namespaces': d({
1190
+ "DX": {
1191
+ 'data types': d({
1192
+ }),
1193
+ 'namespaces': d({
1194
+ "G": {
1195
+ 'data types': d({
1196
+ }),
1197
+ 'namespaces': d({
1198
+ "target types": {
1199
+ 'data types': d({
1200
+ }),
1201
+ 'namespaces': d({
1202
+ "DX": {
1203
+ 'data types': d({
1204
+ }),
1205
+ 'namespaces': d({
1206
+ }),
1207
+ },
1208
+ }),
1209
+ },
1210
+ }),
1211
+ },
1212
+ }),
1213
+ },
1214
+ }),
1215
+ },
1216
+ }),
1217
+ },
1218
+ }),
1219
+ },
1220
+ }),
1221
+ },
1222
+ }),
1223
+ },
1224
+ }),
1225
+ },
1226
+ }),
1227
+ },
1228
+ }),
1229
+ },
1230
+ }),
1231
+ },
1232
+ "Data Glossary": {
1233
+ 'data types': d({
1234
+ }),
1235
+ 'namespaces': d({
1236
+ "G": {
1237
+ 'data types': d({
1238
+ }),
1239
+ 'namespaces': d({
1240
+ "glossary parameters": {
1241
+ 'data types': d({
1242
+ }),
1243
+ 'namespaces': d({
1244
+ }),
1245
+ },
1246
+ "imports": {
1247
+ 'data types': d({
1248
+ }),
1249
+ 'namespaces': d({
1250
+ "DX": {
1251
+ 'data types': d({
1252
+ }),
1253
+ 'namespaces': d({
1254
+ "G": {
1255
+ 'data types': d({
1256
+ }),
1257
+ 'namespaces': d({
1258
+ "glossary": {
1259
+ 'data types': d({
1260
+ }),
1261
+ 'namespaces': d({
1262
+ }),
1263
+ },
1264
+ "type arguments": {
1265
+ 'data types': d({
1266
+ }),
1267
+ 'namespaces': d({
1268
+ }),
1269
+ },
1270
+ }),
1271
+ },
1272
+ }),
1273
+ },
1274
+ }),
1275
+ },
1276
+ "root": {
1277
+ 'data types': d({
1278
+ }),
1279
+ 'namespaces': d({
1280
+ }),
1281
+ },
1282
+ }),
1283
+ },
1284
+ }),
1285
+ },
1286
+ "Data Or Synchronous Interface": {
1287
+ 'data types': d({
1288
+ }),
1289
+ 'namespaces': d({
1290
+ "TU": {
1291
+ 'data types': d({
1292
+ }),
1293
+ 'namespaces': d({
1294
+ "data": {
1295
+ 'data types': d({
1296
+ }),
1297
+ 'namespaces': d({
1298
+ }),
1299
+ },
1300
+ "interface": {
1301
+ 'data types': d({
1302
+ }),
1303
+ 'namespaces': d({
1304
+ }),
1305
+ },
1306
+ }),
1307
+ },
1308
+ }),
1309
+ },
1310
+ "Data Type": {
1311
+ 'data types': d({
1312
+ }),
1313
+ 'namespaces': d({
1314
+ "TU": {
1315
+ 'data types': d({
1316
+ }),
1317
+ 'namespaces': d({
1318
+ "boolean": {
1319
+ 'data types': d({
1320
+ }),
1321
+ 'namespaces': d({
1322
+ }),
1323
+ },
1324
+ "component": {
1325
+ 'data types': d({
1326
+ }),
1327
+ 'namespaces': d({
1328
+ }),
1329
+ },
1330
+ "dictionary": {
1331
+ 'data types': d({
1332
+ }),
1333
+ 'namespaces': d({
1334
+ }),
1335
+ },
1336
+ "group": {
1337
+ 'data types': d({
1338
+ }),
1339
+ 'namespaces': d({
1340
+ "DX": {
1341
+ 'data types': d({
1342
+ }),
1343
+ 'namespaces': d({
1344
+ }),
1345
+ },
1346
+ }),
1347
+ },
1348
+ "integer": {
1349
+ 'data types': d({
1350
+ }),
1351
+ 'namespaces': d({
1352
+ }),
1353
+ },
1354
+ "link": {
1355
+ 'data types': d({
1356
+ }),
1357
+ 'namespaces': d({
1358
+ "G": {
1359
+ 'data types': d({
1360
+ }),
1361
+ 'namespaces': d({
1362
+ "forward": {
1363
+ 'data types': d({
1364
+ }),
1365
+ 'namespaces': d({
1366
+ }),
1367
+ },
1368
+ "target": {
1369
+ 'data types': d({
1370
+ }),
1371
+ 'namespaces': d({
1372
+ }),
1373
+ },
1374
+ "value": {
1375
+ 'data types': d({
1376
+ }),
1377
+ 'namespaces': d({
1378
+ }),
1379
+ },
1380
+ }),
1381
+ },
1382
+ }),
1383
+ },
1384
+ "list": {
1385
+ 'data types': d({
1386
+ }),
1387
+ 'namespaces': d({
1388
+ }),
1389
+ },
1390
+ "nothing": {
1391
+ 'data types': d({
1392
+ }),
1393
+ 'namespaces': d({
1394
+ }),
1395
+ },
1396
+ "optional": {
1397
+ 'data types': d({
1398
+ }),
1399
+ 'namespaces': d({
1400
+ }),
1401
+ },
1402
+ "state group": {
1403
+ 'data types': d({
1404
+ }),
1405
+ 'namespaces': d({
1406
+ "DX": {
1407
+ 'data types': d({
1408
+ }),
1409
+ 'namespaces': d({
1410
+ }),
1411
+ },
1412
+ }),
1413
+ },
1414
+ "text": {
1415
+ 'data types': d({
1416
+ }),
1417
+ 'namespaces': d({
1418
+ }),
1419
+ },
1420
+ }),
1421
+ },
1422
+ }),
1423
+ },
1424
+ "Data Type Reference": {
1425
+ 'data types': d({
1426
+ }),
1427
+ 'namespaces': d({
1428
+ "G": {
1429
+ 'data types': d({
1430
+ }),
1431
+ 'namespaces': d({
1432
+ "type": {
1433
+ 'data types': d({
1434
+ }),
1435
+ 'namespaces': d({
1436
+ }),
1437
+ },
1438
+ "type arguments": {
1439
+ 'data types': d({
1440
+ }),
1441
+ 'namespaces': d({
1442
+ }),
1443
+ },
1444
+ }),
1445
+ },
1446
+ }),
1447
+ },
1448
+ "Data Type Specifier": {
1449
+ 'data types': d({
1450
+ }),
1451
+ 'namespaces': d({
1452
+ "TU": {
1453
+ 'data types': d({
1454
+ }),
1455
+ 'namespaces': d({
1456
+ "glossary parameterXX": {
1457
+ 'data types': d({
1458
+ }),
1459
+ 'namespaces': d({
1460
+ }),
1461
+ },
1462
+ "type": {
1463
+ 'data types': d({
1464
+ }),
1465
+ 'namespaces': d({
1466
+ "G": {
1467
+ 'data types': d({
1468
+ }),
1469
+ 'namespaces': d({
1470
+ "context": {
1471
+ 'data types': d({
1472
+ }),
1473
+ 'namespaces': d({
1474
+ "TU": {
1475
+ 'data types': d({
1476
+ }),
1477
+ 'namespaces': d({
1478
+ "import": {
1479
+ 'data types': d({
1480
+ }),
1481
+ 'namespaces': d({
1482
+ "G": {
1483
+ 'data types': d({
1484
+ }),
1485
+ 'namespaces': d({
1486
+ "glossary": {
1487
+ 'data types': d({
1488
+ }),
1489
+ 'namespaces': d({
1490
+ }),
1491
+ },
1492
+ }),
1493
+ },
1494
+ }),
1495
+ },
1496
+ "local": {
1497
+ 'data types': d({
1498
+ }),
1499
+ 'namespaces': d({
1500
+ }),
1501
+ },
1502
+ }),
1503
+ },
1504
+ }),
1505
+ },
1506
+ "tailXX": {
1507
+ 'data types': d({
1508
+ }),
1509
+ 'namespaces': d({
1510
+ "A": {
1511
+ 'data types': d({
1512
+ }),
1513
+ 'namespaces': d({
1514
+ }),
1515
+ },
1516
+ }),
1517
+ },
1518
+ "type arguments": {
1519
+ 'data types': d({
1520
+ }),
1521
+ 'namespaces': d({
1522
+ }),
1523
+ },
1524
+ "typeXX": {
1525
+ 'data types': d({
1526
+ }),
1527
+ 'namespaces': d({
1528
+ }),
1529
+ },
1530
+ }),
1531
+ },
1532
+ }),
1533
+ },
1534
+ "type parameterXX": {
1535
+ 'data types': d({
1536
+ }),
1537
+ 'namespaces': d({
1538
+ }),
1539
+ },
1540
+ }),
1541
+ },
1542
+ }),
1543
+ },
1544
+ "Glossary": {
1545
+ 'data types': d({
1546
+ }),
1547
+ 'namespaces': d({
1548
+ "G": {
1549
+ 'data types': d({
1550
+ }),
1551
+ 'namespaces': d({
1552
+ "algorithm types": {
1553
+ 'data types': d({
1554
+ }),
1555
+ 'namespaces': d({
1556
+ "DX": {
1557
+ 'data types': d({
1558
+ }),
1559
+ 'namespaces': d({
1560
+ "G": {
1561
+ 'data types': d({
1562
+ }),
1563
+ 'namespaces': d({
1564
+ "parameters": {
1565
+ 'data types': d({
1566
+ }),
1567
+ 'namespaces': d({
1568
+ }),
1569
+ },
1570
+ "type": {
1571
+ 'data types': d({
1572
+ }),
1573
+ 'namespaces': d({
1574
+ "TU": {
1575
+ 'data types': d({
1576
+ }),
1577
+ 'namespaces': d({
1578
+ "asynchronous function": {
1579
+ 'data types': d({
1580
+ }),
1581
+ 'namespaces': d({
1582
+ "G": {
1583
+ 'data types': d({
1584
+ }),
1585
+ 'namespaces': d({
1586
+ "in": {
1587
+ 'data types': d({
1588
+ }),
1589
+ 'namespaces': d({
1590
+ }),
1591
+ },
1592
+ "out": {
1593
+ 'data types': d({
1594
+ }),
1595
+ 'namespaces': d({
1596
+ }),
1597
+ },
1598
+ }),
1599
+ },
1600
+ }),
1601
+ },
1602
+ "interface initializer": {
1603
+ 'data types': d({
1604
+ }),
1605
+ 'namespaces': d({
1606
+ "G": {
1607
+ 'data types': d({
1608
+ }),
1609
+ 'namespaces': d({
1610
+ "downstreams": {
1611
+ 'data types': d({
1612
+ }),
1613
+ 'namespaces': d({
1614
+ "DX": {
1615
+ 'data types': d({
1616
+ }),
1617
+ 'namespaces': d({
1618
+ }),
1619
+ },
1620
+ }),
1621
+ },
1622
+ "interface": {
1623
+ 'data types': d({
1624
+ }),
1625
+ 'namespaces': d({
1626
+ }),
1627
+ },
1628
+ }),
1629
+ },
1630
+ }),
1631
+ },
1632
+ "procedure": {
1633
+ 'data types': d({
1634
+ }),
1635
+ 'namespaces': d({
1636
+ "G": {
1637
+ 'data types': d({
1638
+ }),
1639
+ 'namespaces': d({
1640
+ "in": {
1641
+ 'data types': d({
1642
+ }),
1643
+ 'namespaces': d({
1644
+ }),
1645
+ },
1646
+ "out": {
1647
+ 'data types': d({
1648
+ }),
1649
+ 'namespaces': d({
1650
+ }),
1651
+ },
1652
+ }),
1653
+ },
1654
+ }),
1655
+ },
1656
+ "resource initializer": {
1657
+ 'data types': d({
1658
+ }),
1659
+ 'namespaces': d({
1660
+ "G": {
1661
+ 'data types': d({
1662
+ }),
1663
+ 'namespaces': d({
1664
+ "consumer": {
1665
+ 'data types': d({
1666
+ }),
1667
+ 'namespaces': d({
1668
+ }),
1669
+ },
1670
+ "request": {
1671
+ 'data types': d({
1672
+ }),
1673
+ 'namespaces': d({
1674
+ }),
1675
+ },
1676
+ }),
1677
+ },
1678
+ }),
1679
+ },
1680
+ "synchronous function": {
1681
+ 'data types': d({
1682
+ }),
1683
+ 'namespaces': d({
1684
+ "G": {
1685
+ 'data types': d({
1686
+ }),
1687
+ 'namespaces': d({
1688
+ "in": {
1689
+ 'data types': d({
1690
+ }),
1691
+ 'namespaces': d({
1692
+ }),
1693
+ },
1694
+ "out": {
1695
+ 'data types': d({
1696
+ }),
1697
+ 'namespaces': d({
1698
+ }),
1699
+ },
1700
+ }),
1701
+ },
1702
+ }),
1703
+ },
1704
+ }),
1705
+ },
1706
+ }),
1707
+ },
1708
+ }),
1709
+ },
1710
+ }),
1711
+ },
1712
+ }),
1713
+ },
1714
+ "data glossary": {
1715
+ 'data types': d({
1716
+ }),
1717
+ 'namespaces': d({
1718
+ }),
1719
+ },
1720
+ "interface types": {
1721
+ 'data types': d({
1722
+ }),
1723
+ 'namespaces': d({
1724
+ "DX": {
1725
+ 'data types': d({
1726
+ }),
1727
+ 'namespaces': d({
1728
+ "G": {
1729
+ 'data types': d({
1730
+ }),
1731
+ 'namespaces': d({
1732
+ "parameters": {
1733
+ 'data types': d({
1734
+ }),
1735
+ 'namespaces': d({
1736
+ }),
1737
+ },
1738
+ "type": {
1739
+ 'data types': d({
1740
+ }),
1741
+ 'namespaces': d({
1742
+ "TU": {
1743
+ 'data types': d({
1744
+ }),
1745
+ 'namespaces': d({
1746
+ "asynchronous": {
1747
+ 'data types': d({
1748
+ }),
1749
+ 'namespaces': d({
1750
+ "G": {
1751
+ 'data types': d({
1752
+ }),
1753
+ 'namespaces': d({
1754
+ "interface": {
1755
+ 'data types': d({
1756
+ }),
1757
+ 'namespaces': d({
1758
+ }),
1759
+ },
1760
+ }),
1761
+ },
1762
+ }),
1763
+ },
1764
+ "synchronous": {
1765
+ 'data types': d({
1766
+ }),
1767
+ 'namespaces': d({
1768
+ "G": {
1769
+ 'data types': d({
1770
+ }),
1771
+ 'namespaces': d({
1772
+ "interface": {
1773
+ 'data types': d({
1774
+ }),
1775
+ 'namespaces': d({
1776
+ }),
1777
+ },
1778
+ }),
1779
+ },
1780
+ }),
1781
+ },
1782
+ }),
1783
+ },
1784
+ }),
1785
+ },
1786
+ }),
1787
+ },
1788
+ }),
1789
+ },
1790
+ }),
1791
+ },
1792
+ }),
1793
+ },
1794
+ }),
1795
+ },
1796
+ "Glossary Reference": {
1797
+ 'data types': d({
1798
+ }),
1799
+ 'namespaces': d({
1800
+ "G": {
1801
+ 'data types': d({
1802
+ }),
1803
+ 'namespaces': d({
1804
+ "glossary": {
1805
+ 'data types': d({
1806
+ }),
1807
+ 'namespaces': d({
1808
+ }),
1809
+ },
1810
+ }),
1811
+ },
1812
+ }),
1813
+ },
1814
+ "Library": {
1815
+ 'data types': d({
1816
+ }),
1817
+ 'namespaces': d({
1818
+ "G": {
1819
+ 'data types': d({
1820
+ }),
1821
+ 'namespaces': d({
1822
+ "author": {
1823
+ 'data types': d({
1824
+ }),
1825
+ 'namespaces': d({
1826
+ }),
1827
+ },
1828
+ "description": {
1829
+ 'data types': d({
1830
+ }),
1831
+ 'namespaces': d({
1832
+ }),
1833
+ },
1834
+ "license": {
1835
+ 'data types': d({
1836
+ }),
1837
+ 'namespaces': d({
1838
+ }),
1839
+ },
1840
+ "module sets": {
1841
+ 'data types': d({
1842
+ }),
1843
+ 'namespaces': d({
1844
+ "G": {
1845
+ 'data types': d({
1846
+ }),
1847
+ 'namespaces': d({
1848
+ "private": {
1849
+ 'data types': d({
1850
+ }),
1851
+ 'namespaces': d({
1852
+ }),
1853
+ },
1854
+ "public": {
1855
+ 'data types': d({
1856
+ }),
1857
+ 'namespaces': d({
1858
+ }),
1859
+ },
1860
+ }),
1861
+ },
1862
+ }),
1863
+ },
1864
+ "type": {
1865
+ 'data types': d({
1866
+ }),
1867
+ 'namespaces': d({
1868
+ "TU": {
1869
+ 'data types': d({
1870
+ }),
1871
+ 'namespaces': d({
1872
+ "composite": {
1873
+ 'data types': d({
1874
+ }),
1875
+ 'namespaces': d({
1876
+ "G": {
1877
+ 'data types': d({
1878
+ }),
1879
+ 'namespaces': d({
1880
+ "dependencies": {
1881
+ 'data types': d({
1882
+ }),
1883
+ 'namespaces': d({
1884
+ "DX": {
1885
+ 'data types': d({
1886
+ }),
1887
+ 'namespaces': d({
1888
+ "G": {
1889
+ 'data types': d({
1890
+ }),
1891
+ 'namespaces': d({
1892
+ "library": {
1893
+ 'data types': d({
1894
+ }),
1895
+ 'namespaces': d({
1896
+ }),
1897
+ },
1898
+ "version": {
1899
+ 'data types': d({
1900
+ }),
1901
+ 'namespaces': d({
1902
+ }),
1903
+ },
1904
+ }),
1905
+ },
1906
+ }),
1907
+ },
1908
+ }),
1909
+ },
1910
+ "pure": {
1911
+ 'data types': d({
1912
+ }),
1913
+ 'namespaces': d({
1914
+ }),
1915
+ },
1916
+ }),
1917
+ },
1918
+ }),
1919
+ },
1920
+ "primitive": {
1921
+ 'data types': d({
1922
+ }),
1923
+ 'namespaces': d({
1924
+ "G": {
1925
+ 'data types': d({
1926
+ }),
1927
+ 'namespaces': d({
1928
+ }),
1929
+ },
1930
+ }),
1931
+ },
1932
+ }),
1933
+ },
1934
+ }),
1935
+ },
1936
+ }),
1937
+ },
1938
+ }),
1939
+ },
1940
+ "Module Set": {
1941
+ 'data types': d({
1942
+ }),
1943
+ 'namespaces': d({
1944
+ "G": {
1945
+ 'data types': d({
1946
+ }),
1947
+ 'namespaces': d({
1948
+ "glossaries": {
1949
+ 'data types': d({
1950
+ }),
1951
+ 'namespaces': d({
1952
+ "DX": {
1953
+ 'data types': d({
1954
+ }),
1955
+ 'namespaces': d({
1956
+ "G": {
1957
+ 'data types': d({
1958
+ }),
1959
+ 'namespaces': d({
1960
+ "description": {
1961
+ 'data types': d({
1962
+ }),
1963
+ 'namespaces': d({
1964
+ }),
1965
+ },
1966
+ "glossary": {
1967
+ 'data types': d({
1968
+ }),
1969
+ 'namespaces': d({
1970
+ }),
1971
+ },
1972
+ }),
1973
+ },
1974
+ }),
1975
+ },
1976
+ }),
1977
+ },
1978
+ "modules": {
1979
+ 'data types': d({
1980
+ }),
1981
+ 'namespaces': d({
1982
+ "DX": {
1983
+ 'data types': d({
1984
+ }),
1985
+ 'namespaces': d({
1986
+ }),
1987
+ },
1988
+ }),
1989
+ },
1990
+ "transformations": {
1991
+ 'data types': d({
1992
+ }),
1993
+ 'namespaces': d({
1994
+ "G": {
1995
+ 'data types': d({
1996
+ }),
1997
+ 'namespaces': d({
1998
+ "enrich": {
1999
+ 'data types': d({
2000
+ }),
2001
+ 'namespaces': d({
2002
+ "DX": {
2003
+ 'data types': d({
2004
+ }),
2005
+ 'namespaces': d({
2006
+ }),
2007
+ },
2008
+ }),
2009
+ },
2010
+ "yield": {
2011
+ 'data types': d({
2012
+ }),
2013
+ 'namespaces': d({
2014
+ "DX": {
2015
+ 'data types': d({
2016
+ }),
2017
+ 'namespaces': d({
2018
+ }),
2019
+ },
2020
+ }),
2021
+ },
2022
+ }),
2023
+ },
2024
+ }),
2025
+ },
2026
+ }),
2027
+ },
2028
+ }),
2029
+ },
2030
+ "Namespace": {
2031
+ 'data types': d({
2032
+ }),
2033
+ 'namespaces': d({
2034
+ "G": {
2035
+ 'data types': d({
2036
+ }),
2037
+ 'namespaces': d({
2038
+ "data types": {
2039
+ 'data types': d({
2040
+ }),
2041
+ 'namespaces': d({
2042
+ "DX": {
2043
+ 'data types': d({
2044
+ }),
2045
+ 'namespaces': d({
2046
+ "G": {
2047
+ 'data types': d({
2048
+ }),
2049
+ 'namespaces': d({
2050
+ "parameters": {
2051
+ 'data types': d({
2052
+ }),
2053
+ 'namespaces': d({
2054
+ }),
2055
+ },
2056
+ "type": {
2057
+ 'data types': d({
2058
+ }),
2059
+ 'namespaces': d({
2060
+ }),
2061
+ },
2062
+ }),
2063
+ },
2064
+ }),
2065
+ },
2066
+ }),
2067
+ },
2068
+ "namespaces": {
2069
+ 'data types': d({
2070
+ }),
2071
+ 'namespaces': d({
2072
+ "DX": {
2073
+ 'data types': d({
2074
+ }),
2075
+ 'namespaces': d({
2076
+ }),
2077
+ },
2078
+ }),
2079
+ },
2080
+ }),
2081
+ },
2082
+ }),
2083
+ },
2084
+ "Parameters": {
2085
+ 'data types': d({
2086
+ }),
2087
+ 'namespaces': d({
2088
+ "DX": {
2089
+ 'data types': d({
2090
+ }),
2091
+ 'namespaces': d({
2092
+ }),
2093
+ },
2094
+ }),
2095
+ },
2096
+ "Synchronous Interface Reference": {
2097
+ 'data types': d({
2098
+ }),
2099
+ 'namespaces': d({
2100
+ "G": {
2101
+ 'data types': d({
2102
+ }),
2103
+ 'namespaces': d({
2104
+ "context": {
2105
+ 'data types': d({
2106
+ }),
2107
+ 'namespaces': d({
2108
+ "TU": {
2109
+ 'data types': d({
2110
+ }),
2111
+ 'namespaces': d({
2112
+ "import": {
2113
+ 'data types': d({
2114
+ }),
2115
+ 'namespaces': d({
2116
+ "G": {
2117
+ 'data types': d({
2118
+ }),
2119
+ 'namespaces': d({
2120
+ "glossary": {
2121
+ 'data types': d({
2122
+ }),
2123
+ 'namespaces': d({
2124
+ }),
2125
+ },
2126
+ "interfaceXX": {
2127
+ 'data types': d({
2128
+ }),
2129
+ 'namespaces': d({
2130
+ }),
2131
+ },
2132
+ }),
2133
+ },
2134
+ }),
2135
+ },
2136
+ "local": {
2137
+ 'data types': d({
2138
+ }),
2139
+ 'namespaces': d({
2140
+ "G": {
2141
+ 'data types': d({
2142
+ }),
2143
+ 'namespaces': d({
2144
+ "interfaceXX": {
2145
+ 'data types': d({
2146
+ }),
2147
+ 'namespaces': d({
2148
+ }),
2149
+ },
2150
+ }),
2151
+ },
2152
+ }),
2153
+ },
2154
+ }),
2155
+ },
2156
+ }),
2157
+ },
2158
+ "type arguments": {
2159
+ 'data types': d({
2160
+ }),
2161
+ 'namespaces': d({
2162
+ }),
2163
+ },
2164
+ }),
2165
+ },
2166
+ }),
2167
+ },
2168
+ "Synchronous Interface Type": {
2169
+ 'data types': d({
2170
+ }),
2171
+ 'namespaces': d({
2172
+ "TU": {
2173
+ 'data types': d({
2174
+ }),
2175
+ 'namespaces': d({
2176
+ "group": {
2177
+ 'data types': d({
2178
+ }),
2179
+ 'namespaces': d({
2180
+ "G": {
2181
+ 'data types': d({
2182
+ }),
2183
+ 'namespaces': d({
2184
+ "members": {
2185
+ 'data types': d({
2186
+ }),
2187
+ 'namespaces': d({
2188
+ "DX": {
2189
+ 'data types': d({
2190
+ }),
2191
+ 'namespaces': d({
2192
+ }),
2193
+ },
2194
+ }),
2195
+ },
2196
+ }),
2197
+ },
2198
+ }),
2199
+ },
2200
+ "method": {
2201
+ 'data types': d({
2202
+ }),
2203
+ 'namespaces': d({
2204
+ "G": {
2205
+ 'data types': d({
2206
+ }),
2207
+ 'namespaces': d({
2208
+ "data": {
2209
+ 'data types': d({
2210
+ }),
2211
+ 'namespaces': d({
2212
+ "O": {
2213
+ 'data types': d({
2214
+ }),
2215
+ 'namespaces': d({
2216
+ }),
2217
+ },
2218
+ }),
2219
+ },
2220
+ "interface": {
2221
+ 'data types': d({
2222
+ }),
2223
+ 'namespaces': d({
2224
+ "O": {
2225
+ 'data types': d({
2226
+ }),
2227
+ 'namespaces': d({
2228
+ }),
2229
+ },
2230
+ }),
2231
+ },
2232
+ }),
2233
+ },
2234
+ }),
2235
+ },
2236
+ "reference": {
2237
+ 'data types': d({
2238
+ }),
2239
+ 'namespaces': d({
2240
+ }),
2241
+ },
2242
+ }),
2243
+ },
2244
+ }),
2245
+ },
2246
+ "Transformation": {
2247
+ 'data types': d({
2248
+ }),
2249
+ 'namespaces': d({
2250
+ "G": {
2251
+ 'data types': d({
2252
+ }),
2253
+ 'namespaces': d({
2254
+ "parameters": {
2255
+ 'data types': d({
2256
+ }),
2257
+ 'namespaces': d({
2258
+ "DX": {
2259
+ 'data types': d({
2260
+ }),
2261
+ 'namespaces': d({
2262
+ }),
2263
+ },
2264
+ }),
2265
+ },
2266
+ }),
2267
+ },
2268
+ }),
2269
+ },
2270
+ "Transformations": {
2271
+ 'data types': d({
2272
+ }),
2273
+ 'namespaces': d({
2274
+ "G": {
2275
+ 'data types': d({
2276
+ }),
2277
+ 'namespaces': d({
2278
+ "atom": {
2279
+ 'data types': d({
2280
+ }),
2281
+ 'namespaces': d({
2282
+ "G": {
2283
+ 'data types': d({
2284
+ }),
2285
+ 'namespaces': d({
2286
+ "boolean": {
2287
+ 'data types': d({
2288
+ }),
2289
+ 'namespaces': d({
2290
+ "DX": {
2291
+ 'data types': d({
2292
+ }),
2293
+ 'namespaces': d({
2294
+ }),
2295
+ },
2296
+ }),
2297
+ },
2298
+ "dictionary": {
2299
+ 'data types': d({
2300
+ }),
2301
+ 'namespaces': d({
2302
+ "DX": {
2303
+ 'data types': d({
2304
+ }),
2305
+ 'namespaces': d({
2306
+ }),
2307
+ },
2308
+ }),
2309
+ },
2310
+ "integer": {
2311
+ 'data types': d({
2312
+ }),
2313
+ 'namespaces': d({
2314
+ "DX": {
2315
+ 'data types': d({
2316
+ }),
2317
+ 'namespaces': d({
2318
+ }),
2319
+ },
2320
+ }),
2321
+ },
2322
+ "list": {
2323
+ 'data types': d({
2324
+ }),
2325
+ 'namespaces': d({
2326
+ "DX": {
2327
+ 'data types': d({
2328
+ }),
2329
+ 'namespaces': d({
2330
+ }),
2331
+ },
2332
+ }),
2333
+ },
2334
+ "text": {
2335
+ 'data types': d({
2336
+ }),
2337
+ 'namespaces': d({
2338
+ "DX": {
2339
+ 'data types': d({
2340
+ }),
2341
+ 'namespaces': d({
2342
+ }),
2343
+ },
2344
+ }),
2345
+ },
2346
+ }),
2347
+ },
2348
+ }),
2349
+ },
2350
+ "composite": {
2351
+ 'data types': d({
2352
+ }),
2353
+ 'namespaces': d({
2354
+ "G": {
2355
+ 'data types': d({
2356
+ }),
2357
+ 'namespaces': d({
2358
+ "external libraries": {
2359
+ 'data types': d({
2360
+ }),
2361
+ 'namespaces': d({
2362
+ "DX": {
2363
+ 'data types': d({
2364
+ }),
2365
+ 'namespaces': d({
2366
+ }),
2367
+ },
2368
+ }),
2369
+ },
2370
+ "local": {
2371
+ 'data types': d({
2372
+ }),
2373
+ 'namespaces': d({
2374
+ }),
2375
+ },
2376
+ }),
2377
+ },
2378
+ }),
2379
+ },
2380
+ "glossary": {
2381
+ 'data types': d({
2382
+ }),
2383
+ 'namespaces': d({
2384
+ }),
2385
+ },
2386
+ }),
2387
+ },
2388
+ }),
2389
+ },
2390
+ }),
2391
+ },
2390
2392
  }