npm - pareto - Versions diffs - 0.75.2 → 0.76.1 - Mend

pareto 0.75.2 → 0.76.1

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 (216) hide show

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.pareto_4gl_type_system.temp_in_between.data.ts DELETED Viewed

@@ -1,2399 +0,0 @@
-import * as pd from 'pareto-core-data'
-import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-const a = pd.a
-export const $: g_cosmos.D.Data__Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-    }),
-    'root': {
-        'data types': d({
-            "API": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "algorithms": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "definition": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Algorithm Type Reference",
-                        }]],
-                        "dependencies": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                            "algorithm type": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Algorithm Type Reference",
-                            }]],
-                            "module": ['text', null],
-                            "type": ['state group', d({
-                                "library dependency": ['text', null],
-                                "private": ['nothing', null],
-                                "public": ['nothing', null],
-                                "sibling": ['nothing', null],
-                            })],
-                            "type arguments": ['dictionary', ['state group', d({
-                                "api parameter": ['text', null],
-                                "data type": ['text', null],
-                            })]],
-                        })]],
-                        "description": ['text', null],
-                    })]],
-                    "provided interface": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Glossary",
-                    }]],
-                })],
-            },
-            "Algorithm Type Reference": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "algorithm type": ['text', null],
-                })],
-            },
-            "Arguments": {
-                'parameters': d({
-                }),
-                'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                    "content": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type Specifier",
-                    }]],
-                })]],
-            },
-            "Asynchronous Interface Reference": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "context": ['state group', d({
-                        "import": ['group', d<g_cosmos.D.Data__Type>({
-                            "glossary": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Glossary Reference",
-                            }]],
-                        })],
-                        "local": ['nothing', null],
-                    })],
-                    "interfaceXX": ['text', null],
-                    "type arguments": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Arguments",
-                    }]],
-                })],
-            },
-            "Asynchronous Interface Type": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "choice": ['group', d<g_cosmos.D.Data__Type>({
-                        "options": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Asynchronous Interface Type",
-                        }]]],
-                    })],
-                    "method": ['group', d<g_cosmos.D.Data__Type>({
-                        "data": ['optional', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Type Specifier",
-                        }]]],
-                        "interface": ['optional', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Asynchronous Interface Type",
-                        }]]],
-                    })],
-                    "reference": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Asynchronous Interface Reference",
-                    }]],
-                    "streamconsumer": ['group', d<g_cosmos.D.Data__Type>({
-                        "data": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Asynchronous Interface Type",
-                        }]],
-                        "end": ['optional', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Asynchronous Interface Type",
-                        }]]],
-                    })],
-                })],
-            },
-            "Composite Transformations": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "higher glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                            "lower glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                                "target types": ['dictionary', ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Transformation",
-                                }]]],
-                            })]],
-                        })]],
-                    })]],
-                })],
-            },
-            "Data Glossary": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "glossary parameters": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Parameters",
-                    }]],
-                    "imports": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "glossary": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Glossary",
-                        }]],
-                        "type arguments": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Arguments",
-                        }]],
-                    })]],
-                    "root": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Namespace",
-                    }]],
-                })],
-            },
-            "Data Or Synchronous Interface": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "data": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type Specifier",
-                    }]],
-                    "interface": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Synchronous Interface Reference",
-                    }]],
-                })],
-            },
-            "Data Type": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "boolean": ['nothing', null],
-                    "component": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type Specifier",
-                    }]],
-                    "dictionary": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type",
-                    }]],
-                    "group": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type",
-                    }]]],
-                    "integer": ['nothing', null],
-                    "link": ['group', d<g_cosmos.D.Data__Type>({
-                        "forward": ['boolean', null],
-                        "target": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Type Specifier",
-                        }]],
-                        "value": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Type",
-                        }]],
-                    })],
-                    "list": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type",
-                    }]],
-                    "nothing": ['nothing', null],
-                    "optional": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type",
-                    }]],
-                    "state group": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type",
-                    }]]],
-                    "text": ['nothing', null],
-                })],
-            },
-            "Data Type Reference": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "type": ['text', null],
-                    "type arguments": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Arguments",
-                    }]],
-                })],
-            },
-            "Data Type Specifier": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "glossary parameterXX": ['text', null],
-                    "type": ['group', d<g_cosmos.D.Data__Type>({
-                        "context": ['state group', d({
-                            "import": ['group', d<g_cosmos.D.Data__Type>({
-                                "glossary": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Glossary Reference",
-                                }]],
-                            })],
-                            "local": ['nothing', null],
-                        })],
-                        "tailXX": ['list', ['text', null]],
-                        "type arguments": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Arguments",
-                        }]],
-                        "typeXX": ['text', null],
-                    })],
-                    "type parameterXX": ['text', null],
-                })],
-            },
-            "Glossary": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "algorithm types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "parameters": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Parameters",
-                        }]],
-                        "type": ['state group', d({
-                            "asynchronous function": ['group', d<g_cosmos.D.Data__Type>({
-                                "in": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Data Type Specifier",
-                                }]],
-                                "out": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Data Type Specifier",
-                                }]],
-                            })],
-                            "interface initializer": ['group', d<g_cosmos.D.Data__Type>({
-                                "downstreams": ['dictionary', ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Asynchronous Interface Reference",
-                                }]]],
-                                "interface": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Asynchronous Interface Reference",
-                                }]],
-                            })],
-                            "procedure": ['group', d<g_cosmos.D.Data__Type>({
-                                "in": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Data Or Synchronous Interface",
-                                }]],
-                                "out": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Synchronous Interface Reference",
-                                }]],
-                            })],
-                            "resource initializer": ['group', d<g_cosmos.D.Data__Type>({
-                                "consumer": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Asynchronous Interface Reference",
-                                }]],
-                                "request": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Data Type Specifier",
-                                }]],
-                            })],
-                            "synchronous function": ['group', d<g_cosmos.D.Data__Type>({
-                                "in": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Data Or Synchronous Interface",
-                                }]],
-                                "out": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Data Type Specifier",
-                                }]],
-                            })],
-                        })],
-                    })]],
-                    "data glossary": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Glossary",
-                    }]],
-                    "interface types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "parameters": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Parameters",
-                        }]],
-                        "type": ['state group', d({
-                            "asynchronous": ['group', d<g_cosmos.D.Data__Type>({
-                                "interface": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Asynchronous Interface Type",
-                                }]],
-                            })],
-                            "synchronous": ['group', d<g_cosmos.D.Data__Type>({
-                                "interface": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Synchronous Interface Type",
-                                }]],
-                            })],
-                        })],
-                    })]],
-                })],
-            },
-            "Glossary Reference": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "glossary": ['text', null],
-                })],
-            },
-            "Library": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "author": ['text', null],
-                    "description": ['text', null],
-                    "license": ['text', null],
-                    "module sets": ['group', d<g_cosmos.D.Data__Type>({
-                        "private": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Module Set",
-                        }]],
-                        "public": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Module Set",
-                        }]],
-                    })],
-                    "type": ['state group', d({
-                        "composite": ['group', d<g_cosmos.D.Data__Type>({
-                            "dependencies": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                                "library": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Library",
-                                }]],
-                                "version": ['text', null],
-                            })]],
-                            "pure": ['boolean', null],
-                        })],
-                        "primitive": ['group', d<g_cosmos.D.Data__Type>({
-                        })],
-                    })],
-                })],
-            },
-            "Module Set": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "glossaries": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "description": ['text', null],
-                        "glossary": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Glossary",
-                        }]],
-                    })]],
-                    "modules": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "API",
-                    }]]],
-                    "transformations": ['group', d<g_cosmos.D.Data__Type>({
-                        "enrich": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformations",
-                        }]]],
-                        "yield": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformations",
-                        }]]],
-                    })],
-                })],
-            },
-            "Namespace": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "data types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "parameters": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Parameters",
-                        }]],
-                        "type": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Type",
-                        }]],
-                    })]],
-                    "namespaces": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Namespace",
-                    }]]],
-                })],
-            },
-            "Parameters": {
-                'parameters': d({
-                }),
-                'type': ['dictionary', ['nothing', null]],
-            },
-            "Synchronous Interface Reference": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "context": ['state group', d({
-                        "import": ['group', d<g_cosmos.D.Data__Type>({
-                            "glossary": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Glossary Reference",
-                            }]],
-                            "interfaceXX": ['text', null],
-                        })],
-                        "local": ['group', d<g_cosmos.D.Data__Type>({
-                            "interfaceXX": ['text', null],
-                        })],
-                    })],
-                    "type arguments": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Arguments",
-                    }]],
-                })],
-            },
-            "Synchronous Interface Type": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "group": ['group', d<g_cosmos.D.Data__Type>({
-                        "members": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Synchronous Interface Type",
-                        }]]],
-                    })],
-                    "method": ['group', d<g_cosmos.D.Data__Type>({
-                        "data": ['optional', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Data Type Specifier",
-                        }]]],
-                        "interface": ['optional', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Synchronous Interface Type",
-                        }]]],
-                    })],
-                    "reference": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Synchronous Interface Reference",
-                    }]],
-                })],
-            },
-            "Transformation": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "parameters": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Type Reference",
-                    }]]],
-                })],
-            },
-            "Transformations": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "atom": ['group', d<g_cosmos.D.Data__Type>({
-                        "boolean": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformation",
-                        }]]],
-                        "dictionary": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformation",
-                        }]]],
-                        "integer": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformation",
-                        }]]],
-                        "list": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformation",
-                        }]]],
-                        "text": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Transformation",
-                        }]]],
-                    })],
-                    "composite": ['group', d<g_cosmos.D.Data__Type>({
-                        "external libraries": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Composite Transformations",
-                        }]]],
-                        "local": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Composite Transformations",
-                        }]],
-                    })],
-                    "glossary": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Data Glossary",
-                    }]],
-                })],
-            },
-        }),
-        'namespaces': d({
-            "API": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "algorithms": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "definition": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "dependencies": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "DX": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "algorithm type": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                            "module": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                            "type": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "TU": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                            "library dependency": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                }),
-                                                                                            },
-                                                                                            "private": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                }),
-                                                                                            },
-                                                                                            "public": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                }),
-                                                                                            },
-                                                                                            "sibling": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                }),
-                                                                                            },
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                            "type arguments": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "DX": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                            "TU": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                    "api parameter": {
-                                                                                                        'data types': d({
-                                                                                                        }),
-                                                                                                        'namespaces': d({
-                                                                                                        }),
-                                                                                                    },
-                                                                                                    "data type": {
-                                                                                                        'data types': d({
-                                                                                                        }),
-                                                                                                        'namespaces': d({
-                                                                                                        }),
-                                                                                                    },
-                                                                                                }),
-                                                                                            },
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                    "description": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "provided interface": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Algorithm Type Reference": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "algorithm type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Arguments": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "DX": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                        }),
-                    },
-                }),
-            },
-            "Asynchronous Interface Reference": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "context": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "import": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "glossary": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "local": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "interfaceXX": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "type arguments": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Asynchronous Interface Type": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "choice": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "options": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "method": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "data": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "O": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "interface": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "O": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "reference": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "streamconsumer": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "data": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "end": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "O": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Composite Transformations": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "higher glossaries": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "types": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "DX": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "lower glossaries": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "DX": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                            "G": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                    "target types": {
-                                                                                                        'data types': d({
-                                                                                                        }),
-                                                                                                        'namespaces': d({
-                                                                                                            "DX": {
-                                                                                                                'data types': d({
-                                                                                                                }),
-                                                                                                                'namespaces': d({
-                                                                                                                }),
-                                                                                                            },
-                                                                                                        }),
-                                                                                                    },
-                                                                                                }),
-                                                                                            },
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Data Glossary": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "glossary parameters": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "imports": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "glossary": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "type arguments": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "root": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Data Or Synchronous Interface": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "data": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "interface": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Data Type": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "boolean": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "component": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "dictionary": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "group": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "integer": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "link": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "forward": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "target": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "value": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "list": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "nothing": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "optional": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "state group": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "text": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Data Type Reference": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "type arguments": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Data Type Specifier": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "glossary parameterXX": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "context": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "TU": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "import": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "glossary": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                            "local": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "tailXX": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "A": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "type arguments": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "typeXX": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type parameterXX": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Glossary": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "algorithm types": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "parameters": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "type": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "TU": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "asynchronous function": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "in": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                    "out": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "interface initializer": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "downstreams": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                            "DX": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                }),
-                                                                                            },
-                                                                                        }),
-                                                                                    },
-                                                                                    "interface": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "procedure": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "in": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                    "out": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "resource initializer": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "consumer": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                    "request": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "synchronous function": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "in": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                    "out": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "data glossary": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "interface types": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "parameters": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "type": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "TU": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "asynchronous": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "interface": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "synchronous": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "interface": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Glossary Reference": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "glossary": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Library": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "author": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "description": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "license": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "module sets": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "private": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "public": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "composite": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "dependencies": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "DX": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "library": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                    "version": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                            "pure": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "primitive": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Module Set": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "glossaries": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "description": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "glossary": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "modules": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "transformations": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "enrich": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "yield": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Namespace": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "data types": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "parameters": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "type": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "namespaces": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Parameters": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "DX": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                        }),
-                    },
-                }),
-            },
-            "Synchronous Interface Reference": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "context": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "import": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "glossary": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "interfaceXX": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "local": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "interfaceXX": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type arguments": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Synchronous Interface Type": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "group": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "members": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "method": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "data": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "O": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "interface": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "O": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "reference": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Transformation": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "parameters": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Transformations": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "atom": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "boolean": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "dictionary": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "integer": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "list": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "text": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "composite": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "external libraries": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "local": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "glossary": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-        }),
-    },
-}