pareto 0.71.0 → 0.73.0

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/{auto.pareto.data.ts → auto.pareto_3gl_high.temp_in_between.data.ts}

@@ -1,1737 +1,1803 @@
-import * as pd from 'pareto-core-data'
-
-import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__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({
-            "Compilation Unit": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "imports": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "path": ['text', null],
-                    })]],
-                    "root namespace": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Namespace",
-                    }]],
-                })],
-            },
-            "Expression": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "flow": ['state group', d({
-                        "block": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Statement Block",
-                        }]],
-                        "change context": ['group', d<g_cosmos.D.Data__Type>({
-                            "new context selection": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "sub expression": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                        })],
-                        "implement me": ['text', null],
-                        "panic": ['text', null],
-                    })],
-                    "literal": ['state group', d({
-                        "array": ['list', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]]],
-                        "boolean": ['state group', d({
-                            "false": ['nothing', null],
-                            "true": ['nothing', null],
-                        })],
-                        "dictionary": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]]],
-                        "function": ['group', d<g_cosmos.D.Data__Type>({
-                            "block": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Statement Block",
-                            }]],
-                            "temp signature help": ['state group', d({
-                                "has additional parameters": ['nothing', null],
-                                "has no additional parameters": ['nothing', null],
-                                "typed": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Function Signature",
-                                }]],
-                            })],
-                        })],
-                        "group": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]]],
-                        "null": ['nothing', null],
-                        "number": ['integer', null],
-                        "optional": ['state group', d({
-                            "not set": ['nothing', null],
-                            "set": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                        })],
-                        "string": ['text', null],
-                        "tagged union": ['group', d<g_cosmos.D.Data__Type>({
-                            "data": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "state": ['text', null],
-                        })],
-                    })],
-                    "map": ['group', d<g_cosmos.D.Data__Type>({
-                        "selection": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]],
-                        "type": ['state group', d({
-                            "array": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "boolean": ['group', d<g_cosmos.D.Data__Type>({
-                                "false expression": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]],
-                                "true expression": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]],
-                            })],
-                            "dictionary": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "optional": ['group', d<g_cosmos.D.Data__Type>({
-                                "not set": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]],
-                                "set": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]],
-                            })],
-                            "tagged union": ['group', d<g_cosmos.D.Data__Type>({
-                                "cases": ['dictionary', ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]]],
-                                "default": ['optional', ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]]],
-                            })],
-                        })],
-                    })],
-                    "reduce": ['group', d<g_cosmos.D.Data__Type>({
-                        "callback": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]],
-                        "initial": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]],
-                        "selection": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]],
-                    })],
-                    "selection": ['group', d<g_cosmos.D.Data__Type>({
-                        "start": ['state group', d({
-                            "context": ['nothing', null],
-                            "parameter": ['text', null],
-                            "seed": ['nothing', null],
-                            "variable": ['group', d<g_cosmos.D.Data__Type>({
-                                "import": ['optional', ['text', null]],
-                                "namespace path": ['list', ['text', null]],
-                                "variable": ['text', null],
-                            })],
-                        })],
-                        "tail": ['list', ['state group', d({
-                            "call": ['group', d<g_cosmos.D.Data__Type>({
-                                "arguments": ['dictionary', ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]]],
-                                "context": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Expression",
-                                }]],
-                                "type arguments": ['component', ['type', {
-                                    'context': ['local', null],
-                                    'tailXX': a([
-                                    ]),
-                                    'type arguments': d({
-                                    }),
-                                    'typeXX': "Type Arguments",
-                                }]],
-                            })],
-                            "member selection": ['text', null],
-                        })]],
-                    })],
-                })],
-            },
-            "Function Signature": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "context parameter": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]],
-                    "parameters": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]]],
-                    "return type": ['optional', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]]],
-                    "type parameters": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type Parameters",
-                    }]],
-                })],
-            },
-            "Namespace": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "namespaces": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Namespace",
-                    }]]],
-                    "types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                        "type": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Type",
-                        }]],
-                        "type parameters": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Type Parameters",
-                        }]],
-                    })]],
-                    "variables": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Variables",
-                    }]],
-                })],
-            },
-            "Statement Block": {
-                'parameters': d({
-                }),
-                'type': ['group', d<g_cosmos.D.Data__Type>({
-                    "statements": ['list', ['state group', d({
-                        "assignment": ['group', d<g_cosmos.D.Data__Type>({
-                            "expression": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "selection": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                        })],
-                        "change context": ['group', d<g_cosmos.D.Data__Type>({
-                            "new context selection": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "sub statement block": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Statement Block",
-                            }]],
-                        })],
-                        "debug": ['text', null],
-                        "expression": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Expression",
-                        }]],
-                        "if": ['group', d<g_cosmos.D.Data__Type>({
-                            "condition": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                            "else": ['optional', ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Statement Block",
-                            }]]],
-                            "if block": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Statement Block",
-                            }]],
-                        })],
-                        "return": ['group', d<g_cosmos.D.Data__Type>({
-                            "expression": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                        })],
-                        "sub block": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Statement Block",
-                        }]],
-                        "switch": ['group', d<g_cosmos.D.Data__Type>({
-                            "cases": ['dictionary', ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Statement Block",
-                            }]]],
-                            "default": ['optional', ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Statement Block",
-                            }]]],
-                            "select": ['component', ['type', {
-                                'context': ['local', null],
-                                'tailXX': a([
-                                ]),
-                                'type arguments': d({
-                                }),
-                                'typeXX': "Expression",
-                            }]],
-                        })],
-                    })]],
-                    "variables": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Variables",
-                    }]],
-                })],
-            },
-            "Type": {
-                'parameters': d({
-                }),
-                'type': ['state group', d({
-                    "array": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]],
-                    "boolean": ['nothing', null],
-                    "dictionary": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]],
-                    "function": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Function Signature",
-                    }]],
-                    "group": ['group', d<g_cosmos.D.Data__Type>({
-                        "members": ['dictionary', ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Type",
-                        }]]],
-                    })],
-                    "integer": ['nothing', null],
-                    "null": ['nothing', null],
-                    "optional": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]],
-                    "parameter selection": ['text', null],
-                    "string": ['nothing', null],
-                    "tagged union": ['dictionary', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]]],
-                    "type selection": ['group', d<g_cosmos.D.Data__Type>({
-                        "import": ['optional', ['text', null]],
-                        "namespace path": ['list', ['text', null]],
-                        "type": ['text', null],
-                        "type arguments": ['component', ['type', {
-                            'context': ['local', null],
-                            'tailXX': a([
-                            ]),
-                            'type arguments': d({
-                            }),
-                            'typeXX': "Type Arguments",
-                        }]],
-                    })],
-                })],
-            },
-            "Type Arguments": {
-                'parameters': d({
-                }),
-                'type': ['dictionary', ['component', ['type', {
-                    'context': ['local', null],
-                    'tailXX': a([
-                    ]),
-                    'type arguments': d({
-                    }),
-                    'typeXX': "Type",
-                }]]],
-            },
-            "Type Parameters": {
-                'parameters': d({
-                }),
-                'type': ['dictionary', ['nothing', null]],
-            },
-            "Variables": {
-                'parameters': d({
-                }),
-                'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
-                    "expression": ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Expression",
-                    }]],
-                    "mutable": ['boolean', null],
-                    "type": ['optional', ['component', ['type', {
-                        'context': ['local', null],
-                        'tailXX': a([
-                        ]),
-                        'type arguments': d({
-                        }),
-                        'typeXX': "Type",
-                    }]]],
-                })]],
-            },
-        }),
-        'namespaces': d({
-            "Compilation Unit": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "imports": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "path": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "root namespace": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Expression": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "flow": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "block": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "change context": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "new context selection": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "sub expression": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "implement me": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "panic": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "literal": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "TU": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "array": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "A": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "boolean": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "TU": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "false": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "true": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "dictionary": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "function": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "block": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "temp signature help": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "TU": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "has additional parameters": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                            "has no additional parameters": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                            "typed": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "group": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "DX": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "null": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "number": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "optional": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "TU": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "not set": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "set": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "string": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "tagged union": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "G": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "data": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "state": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "map": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "selection": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "type": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "TU": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "array": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "boolean": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "false expression": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                            "true expression": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                            "dictionary": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "optional": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "not set": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                            "set": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                            "tagged union": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "cases": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "DX": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                            "default": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "O": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "reduce": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "callback": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "initial": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "selection": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "selection": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "start": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "TU": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "context": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "parameter": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "seed": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                }),
-                                                            },
-                                                            "variable": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "G": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "import": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "O": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                            "namespace path": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "A": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                            "variable": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "tail": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "A": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "TU": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "call": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "G": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                    "arguments": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                            "DX": {
-                                                                                                'data types': d({
-                                                                                                }),
-                                                                                                'namespaces': d({
-                                                                                                }),
-                                                                                            },
-                                                                                        }),
-                                                                                    },
-                                                                                    "context": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                    "type arguments": {
-                                                                                        'data types': d({
-                                                                                        }),
-                                                                                        'namespaces': d({
-                                                                                        }),
-                                                                                    },
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "member selection": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Function Signature": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "context parameter": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "parameters": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "return type": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "O": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type parameters": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Namespace": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "namespaces": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "types": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "type": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "type parameters": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "variables": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Statement Block": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "G": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "statements": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "A": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "TU": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "assignment": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "G": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "expression": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                    "selection": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                    "change context": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "G": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "new context selection": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                    "sub statement block": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                    "debug": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "expression": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "if": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "G": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "condition": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                    "else": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "O": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "if block": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                    "return": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "G": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "expression": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                    "sub block": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                    "switch": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                            "G": {
-                                                                'data types': d({
-                                                                }),
-                                                                'namespaces': d({
-                                                                    "cases": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "DX": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "default": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                            "O": {
-                                                                                'data types': d({
-                                                                                }),
-                                                                                'namespaces': d({
-                                                                                }),
-                                                                            },
-                                                                        }),
-                                                                    },
-                                                                    "select": {
-                                                                        'data types': d({
-                                                                        }),
-                                                                        'namespaces': d({
-                                                                        }),
-                                                                    },
-                                                                }),
-                                                            },
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "variables": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Type": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "TU": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "array": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "boolean": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "dictionary": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "function": {
-                                '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({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                            "integer": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "null": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "optional": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "parameter selection": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "string": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                }),
-                            },
-                            "tagged union": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                }),
-                            },
-                            "type selection": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "G": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "import": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "O": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "namespace path": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                    "A": {
-                                                        'data types': d({
-                                                        }),
-                                                        'namespaces': d({
-                                                        }),
-                                                    },
-                                                }),
-                                            },
-                                            "type": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                            "type arguments": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-            "Type Arguments": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "DX": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                        }),
-                    },
-                }),
-            },
-            "Type Parameters": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "DX": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                        }),
-                    },
-                }),
-            },
-            "Variables": {
-                'data types': d({
-                }),
-                'namespaces': d({
-                    "DX": {
-                        'data types': d({
-                        }),
-                        'namespaces': d({
-                            "G": {
-                                'data types': d({
-                                }),
-                                'namespaces': d({
-                                    "expression": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                    "mutable": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                        }),
-                                    },
-                                    "type": {
-                                        'data types': d({
-                                        }),
-                                        'namespaces': d({
-                                            "O": {
-                                                'data types': d({
-                                                }),
-                                                'namespaces': d({
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
-                        }),
-                    },
-                }),
-            },
-        }),
-    },
+import * as pd from 'pareto-core-data'
+
+import * as g_cosmos from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__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({
+            "Compilation Unit": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "imports": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
+                        "path": ['text', null],
+                    })]],
+                    "root namespace": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Namespace",
+                    }]],
+                })],
+            },
+            "Directory": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "nodes": ['dictionary', ['state group', d({
+                        "directory": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Directory",
+                        }]],
+                        "file": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Compilation Unit",
+                        }]],
+                    })]],
+                })],
+            },
+            "Expression": {
+                'parameters': d({
+                }),
+                'type': ['state group', d({
+                    "flow": ['state group', d({
+                        "block": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Statement Block",
+                        }]],
+                        "change context": ['group', d<g_cosmos.D.Data__Type>({
+                            "new context selection": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "sub expression": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                        })],
+                        "implement me": ['text', null],
+                        "panic": ['text', null],
+                    })],
+                    "literal": ['state group', d({
+                        "array": ['list', ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]]],
+                        "boolean": ['state group', d({
+                            "false": ['nothing', null],
+                            "true": ['nothing', null],
+                        })],
+                        "dictionary": ['dictionary', ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]]],
+                        "function": ['group', d<g_cosmos.D.Data__Type>({
+                            "block": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Statement Block",
+                            }]],
+                            "temp signature help": ['state group', d({
+                                "has additional parameters": ['nothing', null],
+                                "has no additional parameters": ['nothing', null],
+                                "typed": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Function Signature",
+                                }]],
+                            })],
+                        })],
+                        "group": ['dictionary', ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]]],
+                        "null": ['nothing', null],
+                        "number": ['integer', null],
+                        "optional": ['state group', d({
+                            "not set": ['nothing', null],
+                            "set": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                        })],
+                        "string": ['text', null],
+                        "tagged union": ['group', d<g_cosmos.D.Data__Type>({
+                            "data": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "state": ['text', null],
+                        })],
+                    })],
+                    "map": ['group', d<g_cosmos.D.Data__Type>({
+                        "selection": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]],
+                        "type": ['state group', d({
+                            "array": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "boolean": ['group', d<g_cosmos.D.Data__Type>({
+                                "false expression": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]],
+                                "true expression": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]],
+                            })],
+                            "dictionary": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "optional": ['group', d<g_cosmos.D.Data__Type>({
+                                "not set": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]],
+                                "set": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]],
+                            })],
+                            "tagged union": ['group', d<g_cosmos.D.Data__Type>({
+                                "cases": ['dictionary', ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]]],
+                                "default": ['optional', ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]]],
+                            })],
+                        })],
+                    })],
+                    "reduce": ['group', d<g_cosmos.D.Data__Type>({
+                        "callback": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]],
+                        "initial": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]],
+                        "selection": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]],
+                    })],
+                    "selection": ['group', d<g_cosmos.D.Data__Type>({
+                        "start": ['state group', d({
+                            "context": ['nothing', null],
+                            "parameter": ['text', null],
+                            "seed": ['nothing', null],
+                            "variable": ['group', d<g_cosmos.D.Data__Type>({
+                                "import": ['optional', ['text', null]],
+                                "namespace path": ['list', ['text', null]],
+                                "variable": ['text', null],
+                            })],
+                        })],
+                        "tail": ['list', ['state group', d({
+                            "call": ['group', d<g_cosmos.D.Data__Type>({
+                                "arguments": ['dictionary', ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]]],
+                                "context": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Expression",
+                                }]],
+                                "type arguments": ['component', ['type', {
+                                    'context': ['local', null],
+                                    'tailXX': a([
+                                    ]),
+                                    'type arguments': d({
+                                    }),
+                                    'typeXX': "Type Arguments",
+                                }]],
+                            })],
+                            "member selection": ['text', null],
+                        })]],
+                    })],
+                })],
+            },
+            "Function Signature": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "context parameter": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]],
+                    "parameters": ['dictionary', ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]]],
+                    "return type": ['optional', ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]]],
+                    "type parameters": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type Parameters",
+                    }]],
+                })],
+            },
+            "Namespace": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "namespaces": ['dictionary', ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Namespace",
+                    }]]],
+                    "types": ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
+                        "type": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Type",
+                        }]],
+                        "type parameters": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Type Parameters",
+                        }]],
+                    })]],
+                    "variables": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Variables",
+                    }]],
+                })],
+            },
+            "Statement Block": {
+                'parameters': d({
+                }),
+                'type': ['group', d<g_cosmos.D.Data__Type>({
+                    "statements": ['list', ['state group', d({
+                        "assignment": ['group', d<g_cosmos.D.Data__Type>({
+                            "expression": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "selection": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                        })],
+                        "change context": ['group', d<g_cosmos.D.Data__Type>({
+                            "new context selection": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "sub statement block": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Statement Block",
+                            }]],
+                        })],
+                        "debug": ['text', null],
+                        "expression": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Expression",
+                        }]],
+                        "if": ['group', d<g_cosmos.D.Data__Type>({
+                            "condition": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                            "else": ['optional', ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Statement Block",
+                            }]]],
+                            "if block": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Statement Block",
+                            }]],
+                        })],
+                        "return": ['group', d<g_cosmos.D.Data__Type>({
+                            "expression": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                        })],
+                        "sub block": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Statement Block",
+                        }]],
+                        "switch": ['group', d<g_cosmos.D.Data__Type>({
+                            "cases": ['dictionary', ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Statement Block",
+                            }]]],
+                            "default": ['optional', ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Statement Block",
+                            }]]],
+                            "select": ['component', ['type', {
+                                'context': ['local', null],
+                                'tailXX': a([
+                                ]),
+                                'type arguments': d({
+                                }),
+                                'typeXX': "Expression",
+                            }]],
+                        })],
+                    })]],
+                    "variables": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Variables",
+                    }]],
+                })],
+            },
+            "Type": {
+                'parameters': d({
+                }),
+                'type': ['state group', d({
+                    "array": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]],
+                    "boolean": ['nothing', null],
+                    "dictionary": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]],
+                    "function": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Function Signature",
+                    }]],
+                    "group": ['group', d<g_cosmos.D.Data__Type>({
+                        "members": ['dictionary', ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Type",
+                        }]]],
+                    })],
+                    "integer": ['nothing', null],
+                    "null": ['nothing', null],
+                    "optional": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]],
+                    "parameter selection": ['text', null],
+                    "string": ['nothing', null],
+                    "tagged union": ['dictionary', ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]]],
+                    "type selection": ['group', d<g_cosmos.D.Data__Type>({
+                        "import": ['optional', ['text', null]],
+                        "namespace path": ['list', ['text', null]],
+                        "type": ['text', null],
+                        "type arguments": ['component', ['type', {
+                            'context': ['local', null],
+                            'tailXX': a([
+                            ]),
+                            'type arguments': d({
+                            }),
+                            'typeXX': "Type Arguments",
+                        }]],
+                    })],
+                })],
+            },
+            "Type Arguments": {
+                'parameters': d({
+                }),
+                'type': ['dictionary', ['component', ['type', {
+                    'context': ['local', null],
+                    'tailXX': a([
+                    ]),
+                    'type arguments': d({
+                    }),
+                    'typeXX': "Type",
+                }]]],
+            },
+            "Type Parameters": {
+                'parameters': d({
+                }),
+                'type': ['dictionary', ['nothing', null]],
+            },
+            "Variables": {
+                'parameters': d({
+                }),
+                'type': ['dictionary', ['group', d<g_cosmos.D.Data__Type>({
+                    "expression": ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Expression",
+                    }]],
+                    "mutable": ['boolean', null],
+                    "type": ['optional', ['component', ['type', {
+                        'context': ['local', null],
+                        'tailXX': a([
+                        ]),
+                        'type arguments': d({
+                        }),
+                        'typeXX': "Type",
+                    }]]],
+                })]],
+            },
+        }),
+        'namespaces': d({
+            "Compilation Unit": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "imports": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "path": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "root namespace": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Directory": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "nodes": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "TU": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "directory": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                    "file": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Expression": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "TU": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "flow": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "TU": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "block": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "change context": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "new context selection": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "sub expression": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "implement me": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "panic": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "literal": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "TU": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "array": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "A": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "boolean": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "TU": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "false": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "true": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "dictionary": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "DX": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "function": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "block": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "temp signature help": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "TU": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "has additional parameters": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                            "has no additional parameters": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                            "typed": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "group": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "DX": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "null": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "number": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "optional": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "TU": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "not set": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "set": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "string": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "tagged union": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "G": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "data": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "state": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "map": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "G": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "selection": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "type": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "TU": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "array": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "boolean": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "G": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "false expression": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                            "true expression": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                            "dictionary": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "optional": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "G": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "not set": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                            "set": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                            "tagged union": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "G": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "cases": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                    "DX": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                        }),
+                                                                                    },
+                                                                                }),
+                                                                            },
+                                                                            "default": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                    "O": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                        }),
+                                                                                    },
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "reduce": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "G": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "callback": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "initial": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "selection": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "selection": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "G": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "start": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "TU": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "context": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "parameter": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "seed": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                }),
+                                                            },
+                                                            "variable": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "G": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "import": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                    "O": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                        }),
+                                                                                    },
+                                                                                }),
+                                                                            },
+                                                                            "namespace path": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                    "A": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                        }),
+                                                                                    },
+                                                                                }),
+                                                                            },
+                                                                            "variable": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "tail": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "A": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "TU": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "call": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "G": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                    "arguments": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                            "DX": {
+                                                                                                'data types': d({
+                                                                                                }),
+                                                                                                'namespaces': d({
+                                                                                                }),
+                                                                                            },
+                                                                                        }),
+                                                                                    },
+                                                                                    "context": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                        }),
+                                                                                    },
+                                                                                    "type arguments": {
+                                                                                        'data types': d({
+                                                                                        }),
+                                                                                        'namespaces': d({
+                                                                                        }),
+                                                                                    },
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                    "member selection": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Function Signature": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "context parameter": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "parameters": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                }),
+                            },
+                            "return type": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "O": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                }),
+                            },
+                            "type parameters": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Namespace": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "namespaces": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                }),
+                            },
+                            "types": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "type": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                    "type parameters": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "variables": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Statement Block": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "statements": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "A": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "TU": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "assignment": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "G": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "expression": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                    "selection": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                    "change context": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "G": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "new context selection": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                    "sub statement block": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                    "debug": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                    "expression": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                    "if": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "G": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "condition": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                    "else": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "O": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                    "if block": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                    "return": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "G": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "expression": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                    "sub block": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                    "switch": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                            "G": {
+                                                                'data types': d({
+                                                                }),
+                                                                'namespaces': d({
+                                                                    "cases": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "DX": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                    "default": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                            "O": {
+                                                                                'data types': d({
+                                                                                }),
+                                                                                'namespaces': d({
+                                                                                }),
+                                                                            },
+                                                                        }),
+                                                                    },
+                                                                    "select": {
+                                                                        'data types': d({
+                                                                        }),
+                                                                        'namespaces': d({
+                                                                        }),
+                                                                    },
+                                                                }),
+                                                            },
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "variables": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Type": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "TU": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "array": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "boolean": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "dictionary": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "function": {
+                                '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({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "integer": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "null": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "optional": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "parameter selection": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "string": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                }),
+                            },
+                            "tagged union": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                }),
+                            },
+                            "type selection": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "G": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "import": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "O": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "namespace path": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                    "A": {
+                                                        'data types': d({
+                                                        }),
+                                                        'namespaces': d({
+                                                        }),
+                                                    },
+                                                }),
+                                            },
+                                            "type": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                            "type arguments": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+            "Type Arguments": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "DX": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                        }),
+                    },
+                }),
+            },
+            "Type Parameters": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "DX": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                        }),
+                    },
+                }),
+            },
+            "Variables": {
+                'data types': d({
+                }),
+                'namespaces': d({
+                    "DX": {
+                        'data types': d({
+                        }),
+                        'namespaces': d({
+                            "G": {
+                                'data types': d({
+                                }),
+                                'namespaces': d({
+                                    "expression": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                    "mutable": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                        }),
+                                    },
+                                    "type": {
+                                        'data types': d({
+                                        }),
+                                        'namespaces': d({
+                                            "O": {
+                                                'data types': d({
+                                                }),
+                                                'namespaces': d({
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                        }),
+                    },
+                }),
+            },
+        }),
+    },
 }