pareto 0.68.0 → 0.70.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (59) hide show
  1. package/auto.dist/data/boekhouding.data.d.ts +1 -1
  2. package/auto.dist/data/boekhouding.data.js +8 -8
  3. package/auto.dist/public/modules/cosmos_type_system_2_typescript_intermediate/auto.provided_interface_glossary.d.ts +4 -28
  4. package/auto.dist/public/modules/filesystem_naming/implementations/create_Valid_File_Name.alg.js +61 -46
  5. package/auto.dist/public/modules/main/implementations/temp$_compile$_boekhouding.alg.js +27 -29
  6. package/auto.dist/public/modules/pareto_2_fountain_pen/implementations/compilation_Unit_2_Indented_Lines.alg.js +4 -4
  7. package/auto.pareto/auto.dependencies/index.ts +3 -3
  8. package/auto.pareto/auto.dependencies/pareto-pure/$.data.ts +18 -6
  9. package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/index.ts +1 -1
  10. package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/boolean/api.data.ts +3 -3
  11. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/astn.data.ts +21 -28
  12. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.alan_light.data.ts +477 -385
  13. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_constrained.data.ts +2955 -0
  14. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_resolved.data.ts +2955 -0
  15. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_unconstrained.data.ts +2956 -0
  16. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.boekhouding_unresolved.data.ts +2956 -0
  17. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.cosmos_type_system.data.ts +2320 -1816
  18. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.cosmos_typescript.data.ts +122 -102
  19. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.grammar.data.ts +294 -234
  20. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.graphviz.data.ts +735 -574
  21. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.html.data.ts +3265 -0
  22. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.pareto.data.ts +1655 -1258
  23. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.semantic_versioning.data.ts +114 -92
  24. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril.data.ts +1030 -809
  25. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_possibly_constrained.data.ts +1170 -0
  26. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_resolved.data.ts +991 -769
  27. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_unconstrained.data.ts +1035 -0
  28. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/fountain_pen_directory.data.ts +18 -25
  29. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.data.ts +29 -35
  30. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file_with_escaped_strings.data.ts +22 -27
  31. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/lines.data.ts +8 -14
  32. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/testresult.data.ts +114 -121
  33. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/text.data.ts +8 -14
  34. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/typescript_intermediate.data.ts +48 -53
  35. package/auto.pareto/auto.dependencies/pareto-pure/glossaries/xml.data.ts +57 -0
  36. package/auto.pareto/auto.dependencies/pareto-pure/modules/alan_light_2_fountain_pen_indented_file_with_escaped_strings/glossary.data.ts +2 -2
  37. package/auto.pareto/auto.dependencies/pareto-pure/modules/astn_2_fountain_pen_indented_file_with_escaped_strings/glossary.data.ts +2 -2
  38. package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_graphviz/glossary.data.ts +2 -2
  39. package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_indented_file_with_escaped_strings/api.data.ts +17 -0
  40. package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_indented_file_with_escaped_strings/glossary.data.ts +51 -0
  41. package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_type_system_2_pareto/glossary.data.ts +2 -2
  42. package/auto.pareto/auto.dependencies/pareto-pure/modules/cosmos_typescript_2_fountain_pen_directory/glossary.data.ts +3 -3
  43. package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_indented_file_2_fountain_pen_indented_file/glossary.data.ts +2 -2
  44. package/auto.pareto/auto.dependencies/pareto-pure/modules/fountain_pen_lines_2_lines/glossary.data.ts +2 -2
  45. package/auto.pareto/auto.dependencies/pareto-pure/modules/graphviz_2_fountain_pen_indented_file_with_escaped_strings/glossary.data.ts +2 -2
  46. package/auto.pareto/auto.dependencies/pareto-pure/modules/html_2_xml/api.data.ts +15 -0
  47. package/auto.pareto/auto.dependencies/pareto-pure/modules/html_2_xml/glossary.data.ts +50 -0
  48. package/auto.pareto/auto.dependencies/pareto-pure/modules/pareto_2_typescript_intermediate/glossary.data.ts +2 -2
  49. package/auto.pareto/auto.dependencies/pareto-pure/modules/semantic_versioning_from_text/glossary.data.ts +2 -2
  50. package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_alan_light/glossary.data.ts +2 -2
  51. package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_cosmos_type_system/glossary.data.ts +2 -2
  52. package/auto.pareto/auto.dependencies/pareto-pure/modules/tendril_2_pareto/glossary.data.ts +2 -2
  53. package/auto.pareto/auto.dependencies/pareto-standard-library/modules/boolean/api.data.ts +3 -3
  54. package/auto.pareto/modules/cosmos_type_system_2_typescript_intermediate/api.data.ts +1 -1
  55. package/auto.pareto/modules/cosmos_type_system_2_typescript_intermediate/glossary.data.ts +2 -2
  56. package/auto.pareto/modules/fountain_pen_indented_file_2_fountain_pen_indented_file_with_escaped_texts/glossary.data.ts +2 -2
  57. package/auto.pareto/modules/pareto_2_fountain_pen/glossary.data.ts +3 -3
  58. package/auto.pareto/modules/typescript_intermediate_2_fountain_pen/glossary.data.ts +2 -2
  59. package/package.json +5 -5
package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.cosmos_type_system.data.ts CHANGED
@@ -5,1882 +5,2386 @@ import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.cos
5
5
  const d = pd.d
6
6
  const a = pd.a
7
7
 
8
- export const $: g_cosmos.D.Glossary = {
9
- 'data glossary': {
10
- 'imports': d({}),
11
- 'glossary parameters': d({}),
12
- 'root': {
13
- 'data types': d({
14
- "Algorithm Type Reference": {
15
- 'parameters': d({}),
16
- 'type': <g_cosmos.D.Data__Type>['group', d({
17
- "algorithm type": <g_cosmos.D.Data__Type>['text', null],
18
- })]
19
- },
20
- "API": {
21
- 'parameters': d({}),
22
- 'type': <g_cosmos.D.Data__Type>['group', d({
23
- "algorithms": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
24
- "definition": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
25
30
  'context': ['local', null],
31
+ 'tailXX': a([
32
+ ]),
33
+ 'type arguments': d({
34
+ }),
26
35
  'typeXX': "Algorithm Type Reference",
27
- 'tailXX': a([]),
28
- 'type arguments': d({}),
29
36
  }]],
30
- "dependencies": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
31
- "algorithm type": <g_cosmos.D.Data__Type>['component', ['type', {
32
- 'context': ['local', null],
33
- 'typeXX': "Algorithm Type Reference",
34
- 'tailXX': a([]),
35
- 'type arguments': d({}),
36
- }]],
37
- "module": <g_cosmos.D.Data__Type>['text', null],
38
- "type": <g_cosmos.D.Data__Type>['state group', d({
39
- "library dependency": <g_cosmos.D.Data__Type>['text', null],
40
- "private": <g_cosmos.D.Data__Type>['nothing', null],
41
- "public": <g_cosmos.D.Data__Type>['nothing', null],
42
- "sibling": <g_cosmos.D.Data__Type>['nothing', null],
43
- })],
44
- "type arguments": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['state group', d({
45
- "api parameter": <g_cosmos.D.Data__Type>['text', null],
46
- "data type": <g_cosmos.D.Data__Type>['text', null],
47
- })]],
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],
48
47
  })]],
49
48
  })]],
50
- "provided interface": <g_cosmos.D.Data__Type>['component', ['type', {
51
- 'context': ['local', null],
52
- 'typeXX': "Glossary",
53
- 'tailXX': a([]),
54
- 'type arguments': d({}),
55
- }]],
56
- })]
57
- },
58
- "Arguments": {
59
- 'parameters': d({}),
60
- 'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
49
+ })]],
50
+ "provided interface": ['component', ['type', {
61
51
  'context': ['local', null],
62
- 'typeXX': "Data Type Specifier",
63
- 'tailXX': a([]),
64
- 'type arguments': d({}),
65
- }]]]
66
- },
67
- "Asynchronous Interface Reference": {
68
- 'parameters': d({}),
69
- 'type': <g_cosmos.D.Data__Type>['group', d({
70
- "context": <g_cosmos.D.Data__Type>['state group', d({
71
- "import": <g_cosmos.D.Data__Type>['group', d({
72
- "glossary": <g_cosmos.D.Data__Type>['component', ['type', {
73
- 'context': ['local', null],
74
- 'typeXX': "Glossary Reference",
75
- 'tailXX': a([]),
76
- 'type arguments': d({}),
77
- }]],
78
- })],
79
- "local": <g_cosmos.D.Data__Type>['group', d({})],
80
- })],
81
- "interfaceXX": <g_cosmos.D.Data__Type>['text', null],
82
- "type arguments": <g_cosmos.D.Data__Type>['component', ['type', {
83
- 'context': ['local', null],
84
- 'typeXX': "Arguments",
85
- 'tailXX': a([]),
86
- 'type arguments': d({}),
87
- }]],
88
- })]
89
- },
90
- "Asynchronous Interface Type": {
91
- 'parameters': d({}),
92
- 'type': <g_cosmos.D.Data__Type>['state group', d({
93
- "choice": <g_cosmos.D.Data__Type>['group', d({
94
- "options": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
95
- 'context': ['local', null],
96
- 'typeXX': "Asynchronous Interface Type",
97
- 'tailXX': a([]),
98
- 'type arguments': d({}),
99
- }]]],
100
- })],
101
- "method": <g_cosmos.D.Data__Type>['group', d({
102
- "data": <g_cosmos.D.Data__Type>['optional', <g_cosmos.D.Data__Type>['component', ['type', {
103
- 'context': ['local', null],
104
- 'typeXX': "Data Type Specifier",
105
- 'tailXX': a([]),
106
- 'type arguments': d({}),
107
- }]]],
108
- "interface": <g_cosmos.D.Data__Type>['optional', <g_cosmos.D.Data__Type>['component', ['type', {
109
- 'context': ['local', null],
110
- 'typeXX': "Asynchronous Interface Type",
111
- 'tailXX': a([]),
112
- 'type arguments': d({}),
113
- }]]],
114
- })],
115
- "reference": <g_cosmos.D.Data__Type>['component', ['type', {
116
- 'context': ['local', null],
117
- 'typeXX': "Asynchronous Interface Reference",
118
- 'tailXX': a([]),
119
- 'type arguments': d({}),
120
- }]],
121
- "streamconsumer": <g_cosmos.D.Data__Type>['group', d({
122
- "data": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
123
86
  'context': ['local', null],
124
- 'typeXX': "Asynchronous Interface Type",
125
- 'tailXX': a([]),
126
- 'type arguments': d({}),
87
+ 'tailXX': a([
88
+ ]),
89
+ 'type arguments': d({
90
+ }),
91
+ 'typeXX': "Glossary Reference",
127
92
  }]],
128
- "end": <g_cosmos.D.Data__Type>['optional', <g_cosmos.D.Data__Type>['component', ['type', {
129
- 'context': ['local', null],
130
- 'typeXX': "Asynchronous Interface Type",
131
- 'tailXX': a([]),
132
- 'type arguments': d({}),
133
- }]]],
134
93
  })],
135
- })]
136
- },
137
- "Composite Transformations": {
138
- 'parameters': d({}),
139
- 'type': <g_cosmos.D.Data__Type>['group', d({
140
- "higher glossaries": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
141
- "types": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
142
- "lower glossaries": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
143
- "target types": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
144
- 'context': ['local', null],
145
- 'typeXX': "Transformation",
146
- 'tailXX': a([]),
147
- 'type arguments': d({}),
148
- }]]],
149
- })]],
150
- })]],
151
- })]],
152
- })]
153
- },
154
- "Data Glossary": {
155
- 'parameters': d({}),
156
- 'type': <g_cosmos.D.Data__Type>['group', d({
157
- "glossary parameters": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
158
113
  'context': ['local', null],
159
- 'typeXX': "Parameters",
160
- 'tailXX': a([]),
161
- 'type arguments': d({}),
162
- }]],
163
- "imports": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
164
- "glossary": <g_cosmos.D.Data__Type>['component', ['type', {
165
- 'context': ['local', null],
166
- 'typeXX': "Data Glossary",
167
- 'tailXX': a([]),
168
- 'type arguments': d({}),
169
- }]],
170
- "type arguments": <g_cosmos.D.Data__Type>['component', ['type', {
171
- 'context': ['local', null],
172
- 'typeXX': "Arguments",
173
- 'tailXX': a([]),
174
- 'type arguments': d({}),
175
- }]],
176
- })]],
177
- "root": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
178
149
  'context': ['local', null],
179
- 'typeXX': "Namespace",
180
- 'tailXX': a([]),
181
- 'type arguments': d({}),
150
+ 'tailXX': a([
151
+ ]),
152
+ 'type arguments': d({
153
+ }),
154
+ 'typeXX': "Asynchronous Interface Type",
182
155
  }]],
183
- })]
184
- },
185
- "Data Or Synchronous Interface": {
186
- 'parameters': d({}),
187
- 'type': <g_cosmos.D.Data__Type>['state group', d({
188
- "data": <g_cosmos.D.Data__Type>['component', ['type', {
156
+ "end": ['optional', ['component', ['type', {
189
157
  'context': ['local', null],
190
- 'typeXX': "Data Type Specifier",
191
- 'tailXX': a([]),
192
- 'type arguments': d({}),
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",
193
207
  }]],
194
- "interface": <g_cosmos.D.Data__Type>['component', ['type', {
208
+ "type arguments": ['component', ['type', {
195
209
  'context': ['local', null],
196
- 'typeXX': "Synchronous Interface Reference",
197
- 'tailXX': a([]),
198
- 'type arguments': d({}),
210
+ 'tailXX': a([
211
+ ]),
212
+ 'type arguments': d({
213
+ }),
214
+ 'typeXX': "Arguments",
199
215
  }]],
200
- })]
201
- },
202
- "Data Type": {
203
- 'parameters': d({}),
204
- 'type': <g_cosmos.D.Data__Type>['state group', d({
205
- "boolean": <g_cosmos.D.Data__Type>['group', d({})],
206
- "component": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
207
282
  'context': ['local', null],
283
+ 'tailXX': a([
284
+ ]),
285
+ 'type arguments': d({
286
+ }),
208
287
  'typeXX': "Data Type Specifier",
209
- 'tailXX': a([]),
210
- 'type arguments': d({}),
211
288
  }]],
212
- "dictionary": <g_cosmos.D.Data__Type>['component', ['type', {
289
+ "value": ['component', ['type', {
213
290
  'context': ['local', null],
291
+ 'tailXX': a([
292
+ ]),
293
+ 'type arguments': d({
294
+ }),
214
295
  'typeXX': "Data Type",
215
- 'tailXX': a([]),
216
- 'type arguments': d({}),
217
296
  }]],
218
- "group": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
219
- 'context': ['local', null],
220
- 'typeXX': "Data Type",
221
- 'tailXX': a([]),
222
- 'type arguments': d({}),
223
- }]]],
224
- "integer": <g_cosmos.D.Data__Type>['nothing', null],
225
- "link": <g_cosmos.D.Data__Type>['group', d({
226
- "forward": <g_cosmos.D.Data__Type>['boolean', null],
227
- "target": <g_cosmos.D.Data__Type>['component', ['type', {
228
- 'context': ['local', null],
229
- 'typeXX': "Data Type Specifier",
230
- 'tailXX': a([]),
231
- 'type arguments': d({}),
232
- }]],
233
- "value": <g_cosmos.D.Data__Type>['component', ['type', {
234
- 'context': ['local', null],
235
- 'typeXX': "Data Type",
236
- 'tailXX': a([]),
237
- 'type arguments': d({}),
238
- }]],
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],
239
359
  })],
240
- "list": <g_cosmos.D.Data__Type>['component', ['type', {
360
+ "tailXX": ['list', ['text', null]],
361
+ "type arguments": ['component', ['type', {
241
362
  'context': ['local', null],
242
- 'typeXX': "Data Type",
243
- 'tailXX': a([]),
244
- 'type arguments': d({}),
245
- }]],
246
- "nothing": <g_cosmos.D.Data__Type>['nothing', null],
247
- "optional": <g_cosmos.D.Data__Type>['component', ['type', {
248
- 'context': ['local', null],
249
- 'typeXX': "Data Type",
250
- 'tailXX': a([]),
251
- 'type arguments': d({}),
363
+ 'tailXX': a([
364
+ ]),
365
+ 'type arguments': d({
366
+ }),
367
+ 'typeXX': "Arguments",
252
368
  }]],
253
- "state group": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
254
- 'context': ['local', null],
255
- 'typeXX': "Data Type",
256
- 'tailXX': a([]),
257
- 'type arguments': d({}),
258
- }]]],
259
- "text": <g_cosmos.D.Data__Type>['nothing', null],
260
- })]
261
- },
262
- "Data Type Reference": {
263
- 'parameters': d({}),
264
- 'type': <g_cosmos.D.Data__Type>['group', d({
265
- "type": <g_cosmos.D.Data__Type>['text', null],
266
- "type arguments": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
267
380
  'context': ['local', null],
268
- 'typeXX': "Arguments",
269
- 'tailXX': a([]),
270
- 'type arguments': d({}),
381
+ 'tailXX': a([
382
+ ]),
383
+ 'type arguments': d({
384
+ }),
385
+ 'typeXX': "Parameters",
271
386
  }]],
272
- })]
273
- },
274
- "Data Type Specifier": {
275
- 'parameters': d({}),
276
- 'type': <g_cosmos.D.Data__Type>['state group', d({
277
- "glossary parameterXX": <g_cosmos.D.Data__Type>['text', null],
278
- "type": <g_cosmos.D.Data__Type>['group', d({
279
- "context": <g_cosmos.D.Data__Type>['state group', d({
280
- "import": <g_cosmos.D.Data__Type>['group', d({
281
- "glossary": <g_cosmos.D.Data__Type>['component', ['type', {
282
- 'context': ['local', null],
283
- 'typeXX': "Glossary Reference",
284
- 'tailXX': a([]),
285
- 'type arguments': d({}),
286
- }]],
287
- })],
288
- "local": <g_cosmos.D.Data__Type>['group', d({})],
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
+ }]],
289
405
  })],
290
- "tailXX": <g_cosmos.D.Data__Type>['list', <g_cosmos.D.Data__Type>['text', null]],
291
- "type arguments": <g_cosmos.D.Data__Type>['component', ['type', {
292
- 'context': ['local', null],
293
- 'typeXX': "Arguments",
294
- 'tailXX': a([]),
295
- 'type arguments': d({}),
296
- }]],
297
- "typeXX": <g_cosmos.D.Data__Type>['text', null],
298
- })],
299
- "type parameterXX": <g_cosmos.D.Data__Type>['text', null],
300
- })]
301
- },
302
- "Glossary": {
303
- 'parameters': d({}),
304
- 'type': <g_cosmos.D.Data__Type>['group', d({
305
- "algorithm types": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
306
- "parameters": <g_cosmos.D.Data__Type>['component', ['type', {
307
- 'context': ['local', null],
308
- 'typeXX': "Parameters",
309
- 'tailXX': a([]),
310
- 'type arguments': d({}),
311
- }]],
312
- "type": <g_cosmos.D.Data__Type>['state group', d({
313
- "asynchronous function": <g_cosmos.D.Data__Type>['group', d({
314
- "in": <g_cosmos.D.Data__Type>['component', ['type', {
315
- 'context': ['local', null],
316
- 'typeXX': "Data Type Specifier",
317
- 'tailXX': a([]),
318
- 'type arguments': d({}),
319
- }]],
320
- "out": <g_cosmos.D.Data__Type>['component', ['type', {
321
- 'context': ['local', null],
322
- 'typeXX': "Data Type Specifier",
323
- 'tailXX': a([]),
324
- 'type arguments': d({}),
325
- }]],
326
- })],
327
- "interface initializer": <g_cosmos.D.Data__Type>['group', d({
328
- "downstreams": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
329
- 'context': ['local', null],
330
- 'typeXX': "Asynchronous Interface Reference",
331
- 'tailXX': a([]),
332
- 'type arguments': d({}),
333
- }]]],
334
- "interface": <g_cosmos.D.Data__Type>['component', ['type', {
335
- 'context': ['local', null],
336
- 'typeXX': "Asynchronous Interface Reference",
337
- 'tailXX': a([]),
338
- 'type arguments': d({}),
339
- }]],
340
- })],
341
- "procedure": <g_cosmos.D.Data__Type>['group', d({
342
- "in": <g_cosmos.D.Data__Type>['component', ['type', {
343
- 'context': ['local', null],
344
- 'typeXX': "Data Or Synchronous Interface",
345
- 'tailXX': a([]),
346
- 'type arguments': d({}),
347
- }]],
348
- "out": <g_cosmos.D.Data__Type>['component', ['type', {
349
- 'context': ['local', null],
350
- 'typeXX': "Synchronous Interface Reference",
351
- 'tailXX': a([]),
352
- 'type arguments': d({}),
353
- }]],
354
- })],
355
- "resource initializer": <g_cosmos.D.Data__Type>['group', d({
356
- "consumer": <g_cosmos.D.Data__Type>['component', ['type', {
357
- 'context': ['local', null],
358
- 'typeXX': "Asynchronous Interface Reference",
359
- 'tailXX': a([]),
360
- 'type arguments': d({}),
361
- }]],
362
- "request": <g_cosmos.D.Data__Type>['component', ['type', {
363
- 'context': ['local', null],
364
- 'typeXX': "Data Type Specifier",
365
- 'tailXX': a([]),
366
- 'type arguments': d({}),
367
- }]],
368
- })],
369
- "synchronous function": <g_cosmos.D.Data__Type>['group', d({
370
- "in": <g_cosmos.D.Data__Type>['component', ['type', {
371
- 'context': ['local', null],
372
- 'typeXX': "Data Or Synchronous Interface",
373
- 'tailXX': a([]),
374
- 'type arguments': d({}),
375
- }]],
376
- "out": <g_cosmos.D.Data__Type>['component', ['type', {
377
- 'context': ['local', null],
378
- 'typeXX': "Data Type Specifier",
379
- 'tailXX': a([]),
380
- 'type arguments': d({}),
381
- }]],
382
- })],
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
+ }]],
383
423
  })],
384
- })]],
385
- "data glossary": <g_cosmos.D.Data__Type>['component', ['type', {
386
- 'context': ['local', null],
387
- 'typeXX': "Data Glossary",
388
- 'tailXX': a([]),
389
- 'type arguments': d({}),
390
- }]],
391
- "interface types": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
392
- "parameters": <g_cosmos.D.Data__Type>['component', ['type', {
393
- 'context': ['local', null],
394
- 'typeXX': "Parameters",
395
- 'tailXX': a([]),
396
- 'type arguments': d({}),
397
- }]],
398
- "type": <g_cosmos.D.Data__Type>['state group', d({
399
- "asynchronous": <g_cosmos.D.Data__Type>['group', d({
400
- "interface": <g_cosmos.D.Data__Type>['component', ['type', {
401
- 'context': ['local', null],
402
- 'typeXX': "Asynchronous Interface Type",
403
- 'tailXX': a([]),
404
- 'type arguments': d({}),
405
- }]],
406
- })],
407
- "synchronous": <g_cosmos.D.Data__Type>['group', d({
408
- "interface": <g_cosmos.D.Data__Type>['component', ['type', {
409
- 'context': ['local', null],
410
- 'typeXX': "Synchronous Interface Type",
411
- 'tailXX': a([]),
412
- 'type arguments': d({}),
413
- }]],
414
- })],
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
+ }]],
415
441
  })],
416
- })]],
417
- })]
418
- },
419
- "Glossary Reference": {
420
- 'parameters': d({}),
421
- 'type': <g_cosmos.D.Data__Type>['group', d({
422
- "glossary": <g_cosmos.D.Data__Type>['text', null],
423
- })]
424
- },
425
- "Library": {
426
- 'parameters': d({}),
427
- 'type': <g_cosmos.D.Data__Type>['group', d({
428
- "author": <g_cosmos.D.Data__Type>['text', null],
429
- "description": <g_cosmos.D.Data__Type>['text', null],
430
- "license": <g_cosmos.D.Data__Type>['text', null],
431
- "module sets": <g_cosmos.D.Data__Type>['group', d({
432
- "private": <g_cosmos.D.Data__Type>['component', ['type', {
433
- 'context': ['local', null],
434
- 'typeXX': "Module Set",
435
- 'tailXX': a([]),
436
- 'type arguments': d({}),
437
- }]],
438
- "public": <g_cosmos.D.Data__Type>['component', ['type', {
439
- 'context': ['local', null],
440
- 'typeXX': "Module Set",
441
- 'tailXX': a([]),
442
- 'type arguments': d({}),
443
- }]],
444
- })],
445
- "type": <g_cosmos.D.Data__Type>['state group', d({
446
- "composite": <g_cosmos.D.Data__Type>['group', d({
447
- "dependencies": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
448
- "library": <g_cosmos.D.Data__Type>['component', ['type', {
449
- 'context': ['local', null],
450
- 'typeXX': "Library",
451
- 'tailXX': a([]),
452
- 'type arguments': d({}),
453
- }]],
454
- "version": <g_cosmos.D.Data__Type>['text', null],
455
- })]],
456
- "pure": <g_cosmos.D.Data__Type>['boolean', null],
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
+ }]],
457
477
  })],
458
- "primitive": <g_cosmos.D.Data__Type>['group', d({})],
459
- })],
460
- })]
461
- },
462
- "Module Set": {
463
- 'parameters': d({}),
464
- 'type': <g_cosmos.D.Data__Type>['group', d({
465
- "glossaries": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
466
- "description": <g_cosmos.D.Data__Type>['text', null],
467
- "glossary": <g_cosmos.D.Data__Type>['component', ['type', {
468
- 'context': ['local', null],
469
- 'typeXX': "Data Glossary",
470
- 'tailXX': a([]),
471
- 'type arguments': d({}),
472
- }]],
473
- })]],
474
- "modules": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
475
- 'context': ['local', null],
476
- 'typeXX': "API",
477
- 'tailXX': a([]),
478
- 'type arguments': d({}),
479
- }]]],
480
- "transformations": <g_cosmos.D.Data__Type>['group', d({
481
- "enrich": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
482
- 'context': ['local', null],
483
- 'typeXX': "Transformations",
484
- 'tailXX': a([]),
485
- 'type arguments': d({}),
486
- }]]],
487
- "yield": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
488
- 'context': ['local', null],
489
- 'typeXX': "Transformations",
490
- 'tailXX': a([]),
491
- 'type arguments': d({}),
492
- }]]],
493
478
  })],
494
- })]
495
- },
496
- "Namespace": {
497
- 'parameters': d({}),
498
- 'type': <g_cosmos.D.Data__Type>['group', d({
499
- "data types": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
500
- "parameters": <g_cosmos.D.Data__Type>['component', ['type', {
501
- 'context': ['local', null],
502
- 'typeXX': "Parameters",
503
- 'tailXX': a([]),
504
- 'type arguments': d({}),
505
- }]],
506
- "type": <g_cosmos.D.Data__Type>['component', ['type', {
507
- 'context': ['local', null],
508
- 'typeXX': "Data Type",
509
- 'tailXX': a([]),
510
- 'type arguments': d({}),
511
- }]],
512
- })]],
513
- "namespaces": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
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', {
514
490
  'context': ['local', null],
515
- 'typeXX': "Namespace",
516
- 'tailXX': a([]),
517
- 'type arguments': d({}),
518
- }]]],
519
- })]
520
- },
521
- "Parameters": {
522
- 'parameters': d({}),
523
- 'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({})]]
524
- },
525
- "Synchronous Interface Reference": {
526
- 'parameters': d({}),
527
- 'type': <g_cosmos.D.Data__Type>['group', d({
528
- "context": <g_cosmos.D.Data__Type>['state group', d({
529
- "import": <g_cosmos.D.Data__Type>['group', d({
530
- "glossary": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
531
500
  'context': ['local', null],
532
- 'typeXX': "Glossary Reference",
533
- 'tailXX': a([]),
534
- 'type arguments': d({}),
501
+ 'tailXX': a([
502
+ ]),
503
+ 'type arguments': d({
504
+ }),
505
+ 'typeXX': "Asynchronous Interface Type",
535
506
  }]],
536
- "interfaceXX": <g_cosmos.D.Data__Type>['text', null],
537
507
  })],
538
- "local": <g_cosmos.D.Data__Type>['group', d({
539
- "interfaceXX": <g_cosmos.D.Data__Type>['text', null],
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
+ }]],
540
517
  })],
541
518
  })],
542
- "type arguments": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
543
538
  'context': ['local', null],
544
- 'typeXX': "Arguments",
545
- 'tailXX': a([]),
546
- 'type arguments': d({}),
539
+ 'tailXX': a([
540
+ ]),
541
+ 'type arguments': d({
542
+ }),
543
+ 'typeXX': "Module Set",
547
544
  }]],
548
- })]
549
- },
550
- "Synchronous Interface Type": {
551
- 'parameters': d({}),
552
- 'type': <g_cosmos.D.Data__Type>['state group', d({
553
- "group": <g_cosmos.D.Data__Type>['group', d({
554
- "members": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
555
- 'context': ['local', null],
556
- 'typeXX': "Synchronous Interface Type",
557
- 'tailXX': a([]),
558
- 'type arguments': d({}),
559
- }]]],
560
- })],
561
- "method": <g_cosmos.D.Data__Type>['group', d({
562
- "data": <g_cosmos.D.Data__Type>['optional', <g_cosmos.D.Data__Type>['component', ['type', {
563
- 'context': ['local', null],
564
- 'typeXX': "Data Type Specifier",
565
- 'tailXX': a([]),
566
- 'type arguments': d({}),
567
- }]]],
568
- "interface": <g_cosmos.D.Data__Type>['optional', <g_cosmos.D.Data__Type>['component', ['type', {
569
- 'context': ['local', null],
570
- 'typeXX': "Synchronous Interface Type",
571
- 'tailXX': a([]),
572
- 'type arguments': d({}),
573
- }]]],
574
- })],
575
- "reference": <g_cosmos.D.Data__Type>['component', ['type', {
545
+ "public": ['component', ['type', {
576
546
  'context': ['local', null],
577
- 'typeXX': "Synchronous Interface Reference",
578
- 'tailXX': a([]),
579
- 'type arguments': d({}),
547
+ 'tailXX': a([
548
+ ]),
549
+ 'type arguments': d({
550
+ }),
551
+ 'typeXX': "Module Set",
580
552
  }]],
581
- })]
582
- },
583
- "Transformation": {
584
- 'parameters': d({}),
585
- 'type': <g_cosmos.D.Data__Type>['group', d({
586
- "parameters": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
587
- 'context': ['local', null],
588
- 'typeXX': "Data Type Reference",
589
- 'tailXX': a([]),
590
- 'type arguments': d({}),
591
- }]]],
592
- })]
593
- },
594
- "Transformations": {
595
- 'parameters': d({}),
596
- 'type': <g_cosmos.D.Data__Type>['group', d({
597
- "atom": <g_cosmos.D.Data__Type>['group', d({
598
- "boolean": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
599
- 'context': ['local', null],
600
- 'typeXX': "Transformation",
601
- 'tailXX': a([]),
602
- 'type arguments': d({}),
603
- }]]],
604
- "dictionary": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
605
- 'context': ['local', null],
606
- 'typeXX': "Transformation",
607
- 'tailXX': a([]),
608
- 'type arguments': d({}),
609
- }]]],
610
- "integer": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
611
- 'context': ['local', null],
612
- 'typeXX': "Transformation",
613
- 'tailXX': a([]),
614
- 'type arguments': d({}),
615
- }]]],
616
- "list": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
617
- 'context': ['local', null],
618
- 'typeXX': "Transformation",
619
- 'tailXX': a([]),
620
- 'type arguments': d({}),
621
- }]]],
622
- "text": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
623
- 'context': ['local', null],
624
- 'typeXX': "Transformation",
625
- 'tailXX': a([]),
626
- 'type arguments': d({}),
627
- }]]],
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],
628
568
  })],
629
- "composite": <g_cosmos.D.Data__Type>['group', d({
630
- "external libraries": <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['component', ['type', {
631
- 'context': ['local', null],
632
- 'typeXX': "Composite Transformations",
633
- 'tailXX': a([]),
634
- 'type arguments': d({}),
635
- }]]],
636
- "local": <g_cosmos.D.Data__Type>['component', ['type', {
637
- 'context': ['local', null],
638
- 'typeXX': "Composite Transformations",
639
- 'tailXX': a([]),
640
- 'type arguments': d({}),
641
- }]],
569
+ "primitive": ['group', d<g_cosmos.D.Data__Type>({
642
570
  })],
643
- "glossary": <g_cosmos.D.Data__Type>['component', ['type', {
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', {
644
581
  'context': ['local', null],
582
+ 'tailXX': a([
583
+ ]),
584
+ 'type arguments': d({
585
+ }),
645
586
  'typeXX': "Data Glossary",
646
- 'tailXX': a([]),
647
- 'type arguments': d({}),
648
587
  }]],
649
- })]
650
- },
651
- }),
652
- 'namespaces': d({
653
- "Algorithm Type Reference": {
654
- 'data types': d({}),
655
- 'namespaces': d({
656
- "G": {
657
- 'data types': d({}),
658
- 'namespaces': d({
659
- "algorithm type": {
660
- 'data types': d({}),
661
- 'namespaces': d({}),
662
- },
663
- }),
664
- },
665
- }),
666
- },
667
- "API": {
668
- 'data types': d({}),
669
- 'namespaces': d({
670
- "G": {
671
- 'data types': d({}),
672
- 'namespaces': d({
673
- "algorithms": {
674
- 'data types': d({}),
675
- 'namespaces': d({
676
- "DX": {
677
- 'data types': d({}),
678
- 'namespaces': d({
679
- "G": {
680
- 'data types': d({}),
681
- 'namespaces': d({
682
- "definition": {
683
- 'data types': d({}),
684
- 'namespaces': d({}),
685
- },
686
- "dependencies": {
687
- 'data types': d({}),
688
- 'namespaces': d({
689
- "DX": {
690
- 'data types': d({}),
691
- 'namespaces': d({
692
- "G": {
693
- 'data types': d({}),
694
- 'namespaces': d({
695
- "algorithm type": {
696
- 'data types': d({}),
697
- 'namespaces': d({}),
698
- },
699
- "module": {
700
- 'data types': d({}),
701
- 'namespaces': d({}),
702
- },
703
- "type": {
704
- 'data types': d({}),
705
- 'namespaces': d({
706
- "TU": {
707
- 'data types': d({}),
708
- 'namespaces': d({
709
- "library dependency": {
710
- 'data types': d({}),
711
- 'namespaces': d({}),
712
- },
713
- "private": {
714
- 'data types': d({}),
715
- 'namespaces': d({}),
716
- },
717
- "public": {
718
- 'data types': d({}),
719
- 'namespaces': d({}),
720
- },
721
- "sibling": {
722
- 'data types': d({}),
723
- 'namespaces': d({}),
724
- },
725
- }),
726
- },
727
- }),
728
- },
729
- "type arguments": {
730
- 'data types': d({}),
731
- 'namespaces': d({
732
- "DX": {
733
- 'data types': d({}),
734
- 'namespaces': d({
735
- "TU": {
736
- 'data types': d({}),
737
- 'namespaces': d({
738
- "api parameter": {
739
- 'data types': d({}),
740
- 'namespaces': d({}),
741
- },
742
- "data type": {
743
- 'data types': d({}),
744
- 'namespaces': d({}),
745
- },
746
- }),
747
- },
748
- }),
749
- },
750
- }),
751
- },
752
- }),
753
- },
754
- }),
755
- },
756
- }),
757
- },
758
- }),
759
- },
760
- }),
761
- },
762
- }),
763
- },
764
- "provided interface": {
765
- 'data types': d({}),
766
- 'namespaces': d({}),
767
- },
768
- }),
769
- },
770
- }),
771
- },
772
- "Arguments": {
773
- 'data types': d({}),
774
- 'namespaces': d({
775
- "DX": {
776
- 'data types': d({}),
777
- 'namespaces': d({}),
778
- },
779
- }),
780
- },
781
- "Asynchronous Interface Reference": {
782
- 'data types': d({}),
783
- 'namespaces': d({
784
- "G": {
785
- 'data types': d({}),
786
- 'namespaces': d({
787
- "context": {
788
- 'data types': d({}),
789
- 'namespaces': d({
790
- "TU": {
791
- 'data types': d({}),
792
- 'namespaces': d({
793
- "import": {
794
- 'data types': d({}),
795
- 'namespaces': d({
796
- "G": {
797
- 'data types': d({}),
798
- 'namespaces': d({
799
- "glossary": {
800
- 'data types': d({}),
801
- 'namespaces': d({}),
802
- },
803
- }),
804
- },
805
- }),
806
- },
807
- "local": {
808
- 'data types': d({}),
809
- 'namespaces': d({
810
- "G": {
811
- 'data types': d({}),
812
- 'namespaces': d({}),
813
- },
814
- }),
815
- },
816
- }),
817
- },
818
- }),
819
- },
820
- "interfaceXX": {
821
- 'data types': d({}),
822
- 'namespaces': d({}),
823
- },
824
- "type arguments": {
825
- 'data types': d({}),
826
- 'namespaces': d({}),
827
- },
828
- }),
829
- },
830
- }),
831
- },
832
- "Asynchronous Interface Type": {
833
- 'data types': d({}),
834
- 'namespaces': d({
835
- "TU": {
836
- 'data types': d({}),
837
- 'namespaces': d({
838
- "choice": {
839
- 'data types': d({}),
840
- 'namespaces': d({
841
- "G": {
842
- 'data types': d({}),
843
- 'namespaces': d({
844
- "options": {
845
- 'data types': d({}),
846
- 'namespaces': d({
847
- "DX": {
848
- 'data types': d({}),
849
- 'namespaces': d({}),
850
- },
851
- }),
852
- },
853
- }),
854
- },
855
- }),
856
- },
857
- "method": {
858
- 'data types': d({}),
859
- 'namespaces': d({
860
- "G": {
861
- 'data types': d({}),
862
- 'namespaces': d({
863
- "data": {
864
- 'data types': d({}),
865
- 'namespaces': d({
866
- "O": {
867
- 'data types': d({}),
868
- 'namespaces': d({}),
869
- },
870
- }),
871
- },
872
- "interface": {
873
- 'data types': d({}),
874
- 'namespaces': d({
875
- "O": {
876
- 'data types': d({}),
877
- 'namespaces': d({}),
878
- },
879
- }),
880
- },
881
- }),
882
- },
883
- }),
884
- },
885
- "reference": {
886
- 'data types': d({}),
887
- 'namespaces': d({}),
888
- },
889
- "streamconsumer": {
890
- 'data types': d({}),
891
- 'namespaces': d({
892
- "G": {
893
- 'data types': d({}),
894
- 'namespaces': d({
895
- "data": {
896
- 'data types': d({}),
897
- 'namespaces': d({}),
898
- },
899
- "end": {
900
- 'data types': d({}),
901
- 'namespaces': d({
902
- "O": {
903
- 'data types': d({}),
904
- 'namespaces': d({}),
905
- },
906
- }),
907
- },
908
- }),
909
- },
910
- }),
911
- },
912
- }),
913
- },
914
- }),
915
- },
916
- "Composite Transformations": {
917
- 'data types': d({}),
918
- 'namespaces': d({
919
- "G": {
920
- 'data types': d({}),
921
- 'namespaces': d({
922
- "higher glossaries": {
923
- 'data types': d({}),
924
- 'namespaces': d({
925
- "DX": {
926
- 'data types': d({}),
927
- 'namespaces': d({
928
- "G": {
929
- 'data types': d({}),
930
- 'namespaces': d({
931
- "types": {
932
- 'data types': d({}),
933
- 'namespaces': d({
934
- "DX": {
935
- 'data types': d({}),
936
- 'namespaces': d({
937
- "G": {
938
- 'data types': d({}),
939
- 'namespaces': d({
940
- "lower glossaries": {
941
- 'data types': d({}),
942
- 'namespaces': d({
943
- "DX": {
944
- 'data types': d({}),
945
- 'namespaces': d({
946
- "G": {
947
- 'data types': d({}),
948
- 'namespaces': d({
949
- "target types": {
950
- 'data types': d({}),
951
- 'namespaces': d({
952
- "DX": {
953
- 'data types': d({}),
954
- 'namespaces': d({}),
955
- },
956
- }),
957
- },
958
- }),
959
- },
960
- }),
961
- },
962
- }),
963
- },
964
- }),
965
- },
966
- }),
967
- },
968
- }),
969
- },
970
- }),
971
- },
972
- }),
973
- },
974
- }),
975
- },
976
- }),
977
- },
978
- }),
979
- },
980
- "Data Glossary": {
981
- 'data types': d({}),
982
- 'namespaces': d({
983
- "G": {
984
- 'data types': d({}),
985
- 'namespaces': d({
986
- "glossary parameters": {
987
- 'data types': d({}),
988
- 'namespaces': d({}),
989
- },
990
- "imports": {
991
- 'data types': d({}),
992
- 'namespaces': d({
993
- "DX": {
994
- 'data types': d({}),
995
- 'namespaces': d({
996
- "G": {
997
- 'data types': d({}),
998
- 'namespaces': d({
999
- "glossary": {
1000
- 'data types': d({}),
1001
- 'namespaces': d({}),
1002
- },
1003
- "type arguments": {
1004
- 'data types': d({}),
1005
- 'namespaces': d({}),
1006
- },
1007
- }),
1008
- },
1009
- }),
1010
- },
1011
- }),
1012
- },
1013
- "root": {
1014
- 'data types': d({}),
1015
- 'namespaces': d({}),
1016
- },
1017
- }),
1018
- },
1019
- }),
1020
- },
1021
- "Data Or Synchronous Interface": {
1022
- 'data types': d({}),
1023
- 'namespaces': d({
1024
- "TU": {
1025
- 'data types': d({}),
1026
- 'namespaces': d({
1027
- "data": {
1028
- 'data types': d({}),
1029
- 'namespaces': d({}),
1030
- },
1031
- "interface": {
1032
- 'data types': d({}),
1033
- 'namespaces': d({}),
1034
- },
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({
1035
603
  }),
1036
- },
1037
- }),
1038
- },
1039
- "Data Type": {
1040
- 'data types': d({}),
1041
- 'namespaces': d({
1042
- "TU": {
1043
- 'data types': d({}),
1044
- 'namespaces': d({
1045
- "boolean": {
1046
- 'data types': d({}),
1047
- 'namespaces': d({
1048
- "G": {
1049
- 'data types': d({}),
1050
- 'namespaces': d({}),
1051
- },
1052
- }),
1053
- },
1054
- "component": {
1055
- 'data types': d({}),
1056
- 'namespaces': d({}),
1057
- },
1058
- "dictionary": {
1059
- 'data types': d({}),
1060
- 'namespaces': d({}),
1061
- },
1062
- "group": {
1063
- 'data types': d({}),
1064
- 'namespaces': d({
1065
- "DX": {
1066
- 'data types': d({}),
1067
- 'namespaces': d({}),
1068
- },
1069
- }),
1070
- },
1071
- "integer": {
1072
- 'data types': d({}),
1073
- 'namespaces': d({}),
1074
- },
1075
- "link": {
1076
- 'data types': d({}),
1077
- 'namespaces': d({
1078
- "G": {
1079
- 'data types': d({}),
1080
- 'namespaces': d({
1081
- "forward": {
1082
- 'data types': d({}),
1083
- 'namespaces': d({}),
1084
- },
1085
- "target": {
1086
- 'data types': d({}),
1087
- 'namespaces': d({}),
1088
- },
1089
- "value": {
1090
- 'data types': d({}),
1091
- 'namespaces': d({}),
1092
- },
1093
- }),
1094
- },
1095
- }),
1096
- },
1097
- "list": {
1098
- 'data types': d({}),
1099
- 'namespaces': d({}),
1100
- },
1101
- "nothing": {
1102
- 'data types': d({}),
1103
- 'namespaces': d({}),
1104
- },
1105
- "optional": {
1106
- 'data types': d({}),
1107
- 'namespaces': d({}),
1108
- },
1109
- "state group": {
1110
- 'data types': d({}),
1111
- 'namespaces': d({
1112
- "DX": {
1113
- 'data types': d({}),
1114
- 'namespaces': d({}),
1115
- },
1116
- }),
1117
- },
1118
- "text": {
1119
- 'data types': d({}),
1120
- 'namespaces': d({}),
1121
- },
604
+ 'typeXX': "Transformations",
605
+ }]]],
606
+ "yield": ['dictionary', ['component', ['type', {
607
+ 'context': ['local', null],
608
+ 'tailXX': a([
609
+ ]),
610
+ 'type arguments': d({
1122
611
  }),
1123
- },
1124
- }),
1125
- },
1126
- "Data Type Reference": {
1127
- 'data types': d({}),
1128
- 'namespaces': d({
1129
- "G": {
1130
- 'data types': d({}),
1131
- 'namespaces': d({
1132
- "type": {
1133
- 'data types': d({}),
1134
- 'namespaces': d({}),
1135
- },
1136
- "type arguments": {
1137
- 'data types': d({}),
1138
- 'namespaces': d({}),
1139
- },
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({
1140
627
  }),
1141
- },
1142
- }),
1143
- },
1144
- "Data Type Specifier": {
1145
- 'data types': d({}),
1146
- 'namespaces': d({
1147
- "TU": {
1148
- 'data types': d({}),
1149
- 'namespaces': d({
1150
- "glossary parameterXX": {
1151
- 'data types': d({}),
1152
- 'namespaces': d({}),
1153
- },
1154
- "type": {
1155
- 'data types': d({}),
1156
- 'namespaces': d({
1157
- "G": {
1158
- 'data types': d({}),
1159
- 'namespaces': d({
1160
- "context": {
1161
- 'data types': d({}),
1162
- 'namespaces': d({
1163
- "TU": {
1164
- 'data types': d({}),
1165
- 'namespaces': d({
1166
- "import": {
1167
- 'data types': d({}),
1168
- 'namespaces': d({
1169
- "G": {
1170
- 'data types': d({}),
1171
- 'namespaces': d({
1172
- "glossary": {
1173
- 'data types': d({}),
1174
- 'namespaces': d({}),
1175
- },
1176
- }),
1177
- },
1178
- }),
1179
- },
1180
- "local": {
1181
- 'data types': d({}),
1182
- 'namespaces': d({
1183
- "G": {
1184
- 'data types': d({}),
1185
- 'namespaces': d({}),
1186
- },
1187
- }),
1188
- },
1189
- }),
1190
- },
1191
- }),
1192
- },
1193
- "tailXX": {
1194
- 'data types': d({}),
1195
- 'namespaces': d({
1196
- "A": {
1197
- 'data types': d({}),
1198
- 'namespaces': d({}),
1199
- },
1200
- }),
1201
- },
1202
- "type arguments": {
1203
- 'data types': d({}),
1204
- 'namespaces': d({}),
1205
- },
1206
- "typeXX": {
1207
- 'data types': d({}),
1208
- 'namespaces': d({}),
1209
- },
1210
- }),
1211
- },
1212
- }),
1213
- },
1214
- "type parameterXX": {
1215
- 'data types': d({}),
1216
- 'namespaces': d({}),
1217
- },
628
+ 'typeXX': "Parameters",
629
+ }]],
630
+ "type": ['component', ['type', {
631
+ 'context': ['local', null],
632
+ 'tailXX': a([
633
+ ]),
634
+ 'type arguments': d({
1218
635
  }),
1219
- },
1220
- }),
1221
- },
1222
- "Glossary": {
1223
- 'data types': d({}),
1224
- 'namespaces': d({
1225
- "G": {
1226
- 'data types': d({}),
1227
- 'namespaces': d({
1228
- "algorithm types": {
1229
- 'data types': d({}),
1230
- 'namespaces': d({
1231
- "DX": {
1232
- 'data types': d({}),
1233
- 'namespaces': d({
1234
- "G": {
1235
- 'data types': d({}),
1236
- 'namespaces': d({
1237
- "parameters": {
1238
- 'data types': d({}),
1239
- 'namespaces': d({}),
1240
- },
1241
- "type": {
1242
- 'data types': d({}),
1243
- 'namespaces': d({
1244
- "TU": {
1245
- 'data types': d({}),
1246
- 'namespaces': d({
1247
- "asynchronous function": {
1248
- 'data types': d({}),
1249
- 'namespaces': d({
1250
- "G": {
1251
- 'data types': d({}),
1252
- 'namespaces': d({
1253
- "in": {
1254
- 'data types': d({}),
1255
- 'namespaces': d({}),
1256
- },
1257
- "out": {
1258
- 'data types': d({}),
1259
- 'namespaces': d({}),
1260
- },
1261
- }),
1262
- },
1263
- }),
1264
- },
1265
- "interface initializer": {
1266
- 'data types': d({}),
1267
- 'namespaces': d({
1268
- "G": {
1269
- 'data types': d({}),
1270
- 'namespaces': d({
1271
- "downstreams": {
1272
- 'data types': d({}),
1273
- 'namespaces': d({
1274
- "DX": {
1275
- 'data types': d({}),
1276
- 'namespaces': d({}),
1277
- },
1278
- }),
1279
- },
1280
- "interface": {
1281
- 'data types': d({}),
1282
- 'namespaces': d({}),
1283
- },
1284
- }),
1285
- },
1286
- }),
1287
- },
1288
- "procedure": {
1289
- 'data types': d({}),
1290
- 'namespaces': d({
1291
- "G": {
1292
- 'data types': d({}),
1293
- 'namespaces': d({
1294
- "in": {
1295
- 'data types': d({}),
1296
- 'namespaces': d({}),
1297
- },
1298
- "out": {
1299
- 'data types': d({}),
1300
- 'namespaces': d({}),
1301
- },
1302
- }),
1303
- },
1304
- }),
1305
- },
1306
- "resource initializer": {
1307
- 'data types': d({}),
1308
- 'namespaces': d({
1309
- "G": {
1310
- 'data types': d({}),
1311
- 'namespaces': d({
1312
- "consumer": {
1313
- 'data types': d({}),
1314
- 'namespaces': d({}),
1315
- },
1316
- "request": {
1317
- 'data types': d({}),
1318
- 'namespaces': d({}),
1319
- },
1320
- }),
1321
- },
1322
- }),
1323
- },
1324
- "synchronous function": {
1325
- 'data types': d({}),
1326
- 'namespaces': d({
1327
- "G": {
1328
- 'data types': d({}),
1329
- 'namespaces': d({
1330
- "in": {
1331
- 'data types': d({}),
1332
- 'namespaces': d({}),
1333
- },
1334
- "out": {
1335
- 'data types': d({}),
1336
- 'namespaces': d({}),
1337
- },
1338
- }),
1339
- },
1340
- }),
1341
- },
1342
- }),
1343
- },
1344
- }),
1345
- },
1346
- }),
1347
- },
1348
- }),
1349
- },
1350
- }),
1351
- },
1352
- "data glossary": {
1353
- 'data types': d({}),
1354
- 'namespaces': d({}),
1355
- },
1356
- "interface types": {
1357
- 'data types': d({}),
1358
- 'namespaces': d({
1359
- "DX": {
1360
- 'data types': d({}),
1361
- 'namespaces': d({
1362
- "G": {
1363
- 'data types': d({}),
1364
- 'namespaces': d({
1365
- "parameters": {
1366
- 'data types': d({}),
1367
- 'namespaces': d({}),
1368
- },
1369
- "type": {
1370
- 'data types': d({}),
1371
- 'namespaces': d({
1372
- "TU": {
1373
- 'data types': d({}),
1374
- 'namespaces': d({
1375
- "asynchronous": {
1376
- 'data types': d({}),
1377
- 'namespaces': d({
1378
- "G": {
1379
- 'data types': d({}),
1380
- 'namespaces': d({
1381
- "interface": {
1382
- 'data types': d({}),
1383
- 'namespaces': d({}),
1384
- },
1385
- }),
1386
- },
1387
- }),
1388
- },
1389
- "synchronous": {
1390
- 'data types': d({}),
1391
- 'namespaces': d({
1392
- "G": {
1393
- 'data types': d({}),
1394
- 'namespaces': d({
1395
- "interface": {
1396
- 'data types': d({}),
1397
- 'namespaces': d({}),
1398
- },
1399
- }),
1400
- },
1401
- }),
1402
- },
1403
- }),
1404
- },
1405
- }),
1406
- },
1407
- }),
1408
- },
1409
- }),
1410
- },
1411
- }),
1412
- },
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({
1413
694
  }),
1414
- },
1415
- }),
1416
- },
1417
- "Glossary Reference": {
1418
- 'data types': d({}),
1419
- 'namespaces': d({
1420
- "G": {
1421
- 'data types': d({}),
1422
- 'namespaces': d({
1423
- "glossary": {
1424
- 'data types': d({}),
1425
- 'namespaces': d({}),
1426
- },
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({
1427
704
  }),
1428
- },
1429
- }),
1430
- },
1431
- "Library": {
1432
- 'data types': d({}),
1433
- 'namespaces': d({
1434
- "G": {
1435
- 'data types': d({}),
1436
- 'namespaces': d({
1437
- "author": {
1438
- 'data types': d({}),
1439
- 'namespaces': d({}),
1440
- },
1441
- "description": {
1442
- 'data types': d({}),
1443
- 'namespaces': d({}),
1444
- },
1445
- "license": {
1446
- 'data types': d({}),
1447
- 'namespaces': d({}),
1448
- },
1449
- "module sets": {
1450
- 'data types': d({}),
1451
- 'namespaces': d({
1452
- "G": {
1453
- 'data types': d({}),
1454
- 'namespaces': d({
1455
- "private": {
1456
- 'data types': d({}),
1457
- 'namespaces': d({}),
1458
- },
1459
- "public": {
1460
- 'data types': d({}),
1461
- 'namespaces': d({}),
1462
- },
1463
- }),
1464
- },
1465
- }),
1466
- },
1467
- "type": {
1468
- 'data types': d({}),
1469
- 'namespaces': d({
1470
- "TU": {
1471
- 'data types': d({}),
1472
- 'namespaces': d({
1473
- "composite": {
1474
- 'data types': d({}),
1475
- 'namespaces': d({
1476
- "G": {
1477
- 'data types': d({}),
1478
- 'namespaces': d({
1479
- "dependencies": {
1480
- 'data types': d({}),
1481
- 'namespaces': d({
1482
- "DX": {
1483
- 'data types': d({}),
1484
- 'namespaces': d({
1485
- "G": {
1486
- 'data types': d({}),
1487
- 'namespaces': d({
1488
- "library": {
1489
- 'data types': d({}),
1490
- 'namespaces': d({}),
1491
- },
1492
- "version": {
1493
- 'data types': d({}),
1494
- 'namespaces': d({}),
1495
- },
1496
- }),
1497
- },
1498
- }),
1499
- },
1500
- }),
1501
- },
1502
- "pure": {
1503
- 'data types': d({}),
1504
- 'namespaces': d({}),
1505
- },
1506
- }),
1507
- },
1508
- }),
1509
- },
1510
- "primitive": {
1511
- 'data types': d({}),
1512
- 'namespaces': d({
1513
- "G": {
1514
- 'data types': d({}),
1515
- 'namespaces': d({}),
1516
- },
1517
- }),
1518
- },
1519
- }),
1520
- },
1521
- }),
1522
- },
705
+ 'typeXX': "Data Type Specifier",
706
+ }]]],
707
+ "interface": ['optional', ['component', ['type', {
708
+ 'context': ['local', null],
709
+ 'tailXX': a([
710
+ ]),
711
+ 'type arguments': d({
1523
712
  }),
1524
- },
1525
- }),
1526
- },
1527
- "Module Set": {
1528
- 'data types': d({}),
1529
- 'namespaces': d({
1530
- "G": {
1531
- 'data types': d({}),
1532
- 'namespaces': d({
1533
- "glossaries": {
1534
- 'data types': d({}),
1535
- 'namespaces': d({
1536
- "DX": {
1537
- 'data types': d({}),
1538
- 'namespaces': d({
1539
- "G": {
1540
- 'data types': d({}),
1541
- 'namespaces': d({
1542
- "description": {
1543
- 'data types': d({}),
1544
- 'namespaces': d({}),
1545
- },
1546
- "glossary": {
1547
- 'data types': d({}),
1548
- 'namespaces': d({}),
1549
- },
1550
- }),
1551
- },
1552
- }),
1553
- },
1554
- }),
1555
- },
1556
- "modules": {
1557
- 'data types': d({}),
1558
- 'namespaces': d({
1559
- "DX": {
1560
- 'data types': d({}),
1561
- 'namespaces': d({}),
1562
- },
1563
- }),
1564
- },
1565
- "transformations": {
1566
- 'data types': d({}),
1567
- 'namespaces': d({
1568
- "G": {
1569
- 'data types': d({}),
1570
- 'namespaces': d({
1571
- "enrich": {
1572
- 'data types': d({}),
1573
- 'namespaces': d({
1574
- "DX": {
1575
- 'data types': d({}),
1576
- 'namespaces': d({}),
1577
- },
1578
- }),
1579
- },
1580
- "yield": {
1581
- 'data types': d({}),
1582
- 'namespaces': d({
1583
- "DX": {
1584
- 'data types': d({}),
1585
- 'namespaces': d({}),
1586
- },
1587
- }),
1588
- },
1589
- }),
1590
- },
1591
- }),
1592
- },
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({
1593
750
  }),
1594
- },
1595
- }),
1596
- },
1597
- "Namespace": {
1598
- 'data types': d({}),
1599
- 'namespaces': d({
1600
- "G": {
1601
- 'data types': d({}),
1602
- 'namespaces': d({
1603
- "data types": {
1604
- 'data types': d({}),
1605
- 'namespaces': d({
1606
- "DX": {
1607
- 'data types': d({}),
1608
- 'namespaces': d({
1609
- "G": {
1610
- 'data types': d({}),
1611
- 'namespaces': d({
1612
- "parameters": {
1613
- 'data types': d({}),
1614
- 'namespaces': d({}),
1615
- },
1616
- "type": {
1617
- 'data types': d({}),
1618
- 'namespaces': d({}),
1619
- },
1620
- }),
1621
- },
1622
- }),
1623
- },
1624
- }),
1625
- },
1626
- "namespaces": {
1627
- 'data types': d({}),
1628
- 'namespaces': d({
1629
- "DX": {
1630
- 'data types': d({}),
1631
- 'namespaces': d({}),
1632
- },
1633
- }),
1634
- },
751
+ 'typeXX': "Transformation",
752
+ }]]],
753
+ "dictionary": ['dictionary', ['component', ['type', {
754
+ 'context': ['local', null],
755
+ 'tailXX': a([
756
+ ]),
757
+ 'type arguments': d({
1635
758
  }),
1636
- },
1637
- }),
1638
- },
1639
- "Parameters": {
1640
- 'data types': d({}),
1641
- 'namespaces': d({
1642
- "DX": {
1643
- 'data types': d({}),
1644
- 'namespaces': d({
1645
- "G": {
1646
- 'data types': d({}),
1647
- 'namespaces': d({}),
1648
- },
759
+ 'typeXX': "Transformation",
760
+ }]]],
761
+ "integer": ['dictionary', ['component', ['type', {
762
+ 'context': ['local', null],
763
+ 'tailXX': a([
764
+ ]),
765
+ 'type arguments': d({
1649
766
  }),
1650
- },
1651
- }),
1652
- },
1653
- "Synchronous Interface Reference": {
1654
- 'data types': d({}),
1655
- 'namespaces': d({
1656
- "G": {
1657
- 'data types': d({}),
1658
- 'namespaces': d({
1659
- "context": {
1660
- 'data types': d({}),
1661
- 'namespaces': d({
1662
- "TU": {
1663
- 'data types': d({}),
1664
- 'namespaces': d({
1665
- "import": {
1666
- 'data types': d({}),
1667
- 'namespaces': d({
1668
- "G": {
1669
- 'data types': d({}),
1670
- 'namespaces': d({
1671
- "glossary": {
1672
- 'data types': d({}),
1673
- 'namespaces': d({}),
1674
- },
1675
- "interfaceXX": {
1676
- 'data types': d({}),
1677
- 'namespaces': d({}),
1678
- },
1679
- }),
1680
- },
1681
- }),
1682
- },
1683
- "local": {
1684
- 'data types': d({}),
1685
- 'namespaces': d({
1686
- "G": {
1687
- 'data types': d({}),
1688
- 'namespaces': d({
1689
- "interfaceXX": {
1690
- 'data types': d({}),
1691
- 'namespaces': d({}),
1692
- },
1693
- }),
1694
- },
1695
- }),
1696
- },
1697
- }),
1698
- },
1699
- }),
1700
- },
1701
- "type arguments": {
1702
- 'data types': d({}),
1703
- 'namespaces': d({}),
1704
- },
767
+ 'typeXX': "Transformation",
768
+ }]]],
769
+ "list": ['dictionary', ['component', ['type', {
770
+ 'context': ['local', null],
771
+ 'tailXX': a([
772
+ ]),
773
+ 'type arguments': d({
1705
774
  }),
1706
- },
1707
- }),
1708
- },
1709
- "Synchronous Interface Type": {
1710
- 'data types': d({}),
1711
- 'namespaces': d({
1712
- "TU": {
1713
- 'data types': d({}),
1714
- 'namespaces': d({
1715
- "group": {
1716
- 'data types': d({}),
1717
- 'namespaces': d({
1718
- "G": {
1719
- 'data types': d({}),
1720
- 'namespaces': d({
1721
- "members": {
1722
- 'data types': d({}),
1723
- 'namespaces': d({
1724
- "DX": {
1725
- 'data types': d({}),
1726
- 'namespaces': d({}),
1727
- },
1728
- }),
1729
- },
1730
- }),
1731
- },
1732
- }),
1733
- },
1734
- "method": {
1735
- 'data types': d({}),
1736
- 'namespaces': d({
1737
- "G": {
1738
- 'data types': d({}),
1739
- 'namespaces': d({
1740
- "data": {
1741
- 'data types': d({}),
1742
- 'namespaces': d({
1743
- "O": {
1744
- 'data types': d({}),
1745
- 'namespaces': d({}),
1746
- },
1747
- }),
1748
- },
1749
- "interface": {
1750
- 'data types': d({}),
1751
- 'namespaces': d({
1752
- "O": {
1753
- 'data types': d({}),
1754
- 'namespaces': d({}),
1755
- },
1756
- }),
1757
- },
1758
- }),
1759
- },
1760
- }),
1761
- },
1762
- "reference": {
1763
- 'data types': d({}),
1764
- 'namespaces': d({}),
1765
- },
775
+ 'typeXX': "Transformation",
776
+ }]]],
777
+ "text": ['dictionary', ['component', ['type', {
778
+ 'context': ['local', null],
779
+ 'tailXX': a([
780
+ ]),
781
+ 'type arguments': d({
1766
782
  }),
1767
- },
1768
- }),
1769
- },
1770
- "Transformation": {
1771
- 'data types': d({}),
1772
- 'namespaces': d({
1773
- "G": {
1774
- 'data types': d({}),
1775
- 'namespaces': d({
1776
- "parameters": {
1777
- 'data types': d({}),
1778
- 'namespaces': d({
1779
- "DX": {
1780
- 'data types': d({}),
1781
- 'namespaces': d({}),
1782
- },
1783
- }),
1784
- },
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({
1785
792
  }),
1786
- },
1787
- }),
1788
- },
1789
- "Transformations": {
1790
- 'data types': d({}),
1791
- 'namespaces': d({
1792
- "G": {
1793
- 'data types': d({}),
1794
- 'namespaces': d({
1795
- "atom": {
1796
- 'data types': d({}),
1797
- 'namespaces': d({
1798
- "G": {
1799
- 'data types': d({}),
1800
- 'namespaces': d({
1801
- "boolean": {
1802
- 'data types': d({}),
1803
- 'namespaces': d({
1804
- "DX": {
1805
- 'data types': d({}),
1806
- 'namespaces': d({}),
1807
- },
1808
- }),
1809
- },
1810
- "dictionary": {
1811
- 'data types': d({}),
1812
- 'namespaces': d({
1813
- "DX": {
1814
- 'data types': d({}),
1815
- 'namespaces': d({}),
1816
- },
1817
- }),
1818
- },
1819
- "integer": {
1820
- 'data types': d({}),
1821
- 'namespaces': d({
1822
- "DX": {
1823
- 'data types': d({}),
1824
- 'namespaces': d({}),
1825
- },
1826
- }),
1827
- },
1828
- "list": {
1829
- 'data types': d({}),
1830
- 'namespaces': d({
1831
- "DX": {
1832
- 'data types': d({}),
1833
- 'namespaces': d({}),
1834
- },
1835
- }),
1836
- },
1837
- "text": {
1838
- 'data types': d({}),
1839
- 'namespaces': d({
1840
- "DX": {
1841
- 'data types': d({}),
1842
- 'namespaces': d({}),
1843
- },
1844
- }),
1845
- },
1846
- }),
1847
- },
1848
- }),
1849
- },
1850
- "composite": {
1851
- 'data types': d({}),
1852
- 'namespaces': d({
1853
- "G": {
1854
- 'data types': d({}),
1855
- 'namespaces': d({
1856
- "external libraries": {
1857
- 'data types': d({}),
1858
- 'namespaces': d({
1859
- "DX": {
1860
- 'data types': d({}),
1861
- 'namespaces': d({}),
1862
- },
1863
- }),
1864
- },
1865
- "local": {
1866
- 'data types': d({}),
1867
- 'namespaces': d({}),
1868
- },
1869
- }),
1870
- },
1871
- }),
1872
- },
1873
- "glossary": {
1874
- 'data types': d({}),
1875
- 'namespaces': d({}),
1876
- },
793
+ 'typeXX': "Composite Transformations",
794
+ }]]],
795
+ "local": ['component', ['type', {
796
+ 'context': ['local', null],
797
+ 'tailXX': a([
798
+ ]),
799
+ 'type arguments': d({
1877
800
  }),
1878
- },
1879
- }),
1880
- },
1881
- }),
1882
- },
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
+ }),
1883
2389
  },
1884
- 'interface types': d({}),
1885
- 'algorithm types': d({}),
1886
2390
  }