pareto 0.58.0 → 0.60.0

package/auto.dist/public/modules/tendril2alan__light/auto.provided_interface_glossary.d.ts

@@ -1,1583 +0,0 @@
-import * as pt from 'pareto-core-types';
-export declare namespace G {
-    namespace alan__light {
-        namespace G { }
-        namespace N {
-            namespace Node {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace properties {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace _$ltype {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace collection {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace key {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace node {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace group {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace node {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace state_$_$group {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace states {
-                                                                                        namespace N {
-                                                                                            namespace DX {
-                                                                                                namespace N {
-                                                                                                    namespace G {
-                                                                                                        namespace N {
-                                                                                                            namespace constraints {
-                                                                                                                namespace N {
-                                                                                                                    namespace DX {
-                                                                                                                        namespace N {
-                                                                                                                            namespace G {
-                                                                                                                                namespace N {
-                                                                                                                                    namespace path {
-                                                                                                                                        namespace N { }
-                                                                                                                                        namespace D { }
-                                                                                                                                    }
-                                                                                                                                }
-                                                                                                                                namespace D { }
-                                                                                                                            }
-                                                                                                                        }
-                                                                                                                        namespace D { }
-                                                                                                                    }
-                                                                                                                }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                            namespace node {
-                                                                                                                namespace N { }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                        }
-                                                                                                        namespace D { }
-                                                                                                    }
-                                                                                                }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace text {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace constraint {
-                                                                                        namespace N {
-                                                                                            namespace O {
-                                                                                                namespace N {
-                                                                                                    namespace G {
-                                                                                                        namespace N {
-                                                                                                            namespace dictionary {
-                                                                                                                namespace N { }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                            namespace path {
-                                                                                                                namespace N { }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                        }
-                                                                                                        namespace D { }
-                                                                                                    }
-                                                                                                }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Path {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace context {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace sibling {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace state_$_$constraint {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace name {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace selection_$_$steps {
-                                namespace N {
-                                    namespace A {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace group {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace name {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace reference {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace name {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace state_$_$constraint {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace name {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace up_$_$steps {
-                                namespace N {
-                                    namespace A {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Root {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace numerical_$_$types {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace root {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D {
-            namespace Node {
-                namespace properties {
-                    namespace DX {
-                        namespace _ltype {
-                            namespace collection {
-                                type key = string;
-                                type node = D.Node;
-                            }
-                            type collection = {
-                                readonly 'key': string;
-                                readonly 'node': D.Node;
-                            };
-                            namespace group {
-                                type node = D.Node;
-                            }
-                            type group = {
-                                readonly 'node': D.Node;
-                            };
-                            namespace state__group {
-                                namespace states {
-                                    namespace DX {
-                                        namespace constraints {
-                                            namespace DX {
-                                                type path = D.Path;
-                                            }
-                                            type DX = {
-                                                readonly 'path': D.Path;
-                                            };
-                                        }
-                                        type constraints = pt.Dictionary<{
-                                            readonly 'path': D.Path;
-                                        }>;
-                                        type node = D.Node;
-                                    }
-                                    type DX = {
-                                        readonly 'constraints': pt.Dictionary<{
-                                            readonly 'path': D.Path;
-                                        }>;
-                                        readonly 'node': D.Node;
-                                    };
-                                }
-                                type states = pt.Dictionary<{
-                                    readonly 'constraints': pt.Dictionary<{
-                                        readonly 'path': D.Path;
-                                    }>;
-                                    readonly 'node': D.Node;
-                                }>;
-                            }
-                            type state__group = {
-                                readonly 'states': pt.Dictionary<{
-                                    readonly 'constraints': pt.Dictionary<{
-                                        readonly 'path': D.Path;
-                                    }>;
-                                    readonly 'node': D.Node;
-                                }>;
-                            };
-                            namespace text {
-                                namespace constraint {
-                                    namespace O {
-                                        type dictionary = string;
-                                        type path = D.Path;
-                                    }
-                                    type O = {
-                                        readonly 'dictionary': string;
-                                        readonly 'path': D.Path;
-                                    };
-                                }
-                                type constraint = pt.OptionalValue<{
-                                    readonly 'dictionary': string;
-                                    readonly 'path': D.Path;
-                                }>;
-                            }
-                            type text = {
-                                readonly 'constraint': pt.OptionalValue<{
-                                    readonly 'dictionary': string;
-                                    readonly 'path': D.Path;
-                                }>;
-                            };
-                        }
-                        type _ltype = [
-                            'collection',
-                            {
-                                readonly 'key': string;
-                                readonly 'node': D.Node;
-                            }
-                        ] | [
-                            'group',
-                            {
-                                readonly 'node': D.Node;
-                            }
-                        ] | [
-                            'state group',
-                            {
-                                readonly 'states': pt.Dictionary<{
-                                    readonly 'constraints': pt.Dictionary<{
-                                        readonly 'path': D.Path;
-                                    }>;
-                                    readonly 'node': D.Node;
-                                }>;
-                            }
-                        ] | [
-                            'text',
-                            {
-                                readonly 'constraint': pt.OptionalValue<{
-                                    readonly 'dictionary': string;
-                                    readonly 'path': D.Path;
-                                }>;
-                            }
-                        ];
-                    }
-                    type DX = {
-                        readonly 'type': [
-                            'collection',
-                            {
-                                readonly 'key': string;
-                                readonly 'node': D.Node;
-                            }
-                        ] | [
-                            'group',
-                            {
-                                readonly 'node': D.Node;
-                            }
-                        ] | [
-                            'state group',
-                            {
-                                readonly 'states': pt.Dictionary<{
-                                    readonly 'constraints': pt.Dictionary<{
-                                        readonly 'path': D.Path;
-                                    }>;
-                                    readonly 'node': D.Node;
-                                }>;
-                            }
-                        ] | [
-                            'text',
-                            {
-                                readonly 'constraint': pt.OptionalValue<{
-                                    readonly 'dictionary': string;
-                                    readonly 'path': D.Path;
-                                }>;
-                            }
-                        ];
-                    };
-                }
-                type properties = pt.Dictionary<{
-                    readonly 'type': [
-                        'collection',
-                        {
-                            readonly 'key': string;
-                            readonly 'node': D.Node;
-                        }
-                    ] | [
-                        'group',
-                        {
-                            readonly 'node': D.Node;
-                        }
-                    ] | [
-                        'state group',
-                        {
-                            readonly 'states': pt.Dictionary<{
-                                readonly 'constraints': pt.Dictionary<{
-                                    readonly 'path': D.Path;
-                                }>;
-                                readonly 'node': D.Node;
-                            }>;
-                        }
-                    ] | [
-                        'text',
-                        {
-                            readonly 'constraint': pt.OptionalValue<{
-                                readonly 'dictionary': string;
-                                readonly 'path': D.Path;
-                            }>;
-                        }
-                    ];
-                }>;
-            }
-            type Node = {
-                readonly 'properties': pt.Dictionary<{
-                    readonly 'type': [
-                        'collection',
-                        {
-                            readonly 'key': string;
-                            readonly 'node': D.Node;
-                        }
-                    ] | [
-                        'group',
-                        {
-                            readonly 'node': D.Node;
-                        }
-                    ] | [
-                        'state group',
-                        {
-                            readonly 'states': pt.Dictionary<{
-                                readonly 'constraints': pt.Dictionary<{
-                                    readonly 'path': D.Path;
-                                }>;
-                                readonly 'node': D.Node;
-                            }>;
-                        }
-                    ] | [
-                        'text',
-                        {
-                            readonly 'constraint': pt.OptionalValue<{
-                                readonly 'dictionary': string;
-                                readonly 'path': D.Path;
-                            }>;
-                        }
-                    ];
-                }>;
-            };
-            namespace Path {
-                namespace context {
-                    namespace sibling { }
-                    type sibling = null;
-                    namespace state__constraint {
-                        type name = string;
-                    }
-                    type state__constraint = {
-                        readonly 'name': string;
-                    };
-                }
-                type context = ['sibling', null] | [
-                    'state constraint',
-                    {
-                        readonly 'name': string;
-                    }
-                ];
-                namespace selection__steps {
-                    namespace A {
-                        namespace group {
-                            type name = string;
-                        }
-                        type group = {
-                            readonly 'name': string;
-                        };
-                        namespace reference {
-                            type name = string;
-                        }
-                        type reference = {
-                            readonly 'name': string;
-                        };
-                        namespace state__constraint {
-                            type name = string;
-                        }
-                        type state__constraint = {
-                            readonly 'name': string;
-                        };
-                    }
-                    type A = [
-                        'group',
-                        {
-                            readonly 'name': string;
-                        }
-                    ] | [
-                        'reference',
-                        {
-                            readonly 'name': string;
-                        }
-                    ] | [
-                        'state constraint',
-                        {
-                            readonly 'name': string;
-                        }
-                    ];
-                }
-                type selection__steps = pt.Array<[
-                    'group',
-                    {
-                        readonly 'name': string;
-                    }
-                ] | [
-                    'reference',
-                    {
-                        readonly 'name': string;
-                    }
-                ] | [
-                    'state constraint',
-                    {
-                        readonly 'name': string;
-                    }
-                ]>;
-                namespace up__steps {
-                    namespace A { }
-                    type A = null;
-                }
-                type up__steps = pt.Array<null>;
-            }
-            type Path = {
-                readonly 'context': ['sibling', null] | [
-                    'state constraint',
-                    {
-                        readonly 'name': string;
-                    }
-                ];
-                readonly 'selection steps': pt.Array<[
-                    'group',
-                    {
-                        readonly 'name': string;
-                    }
-                ] | [
-                    'reference',
-                    {
-                        readonly 'name': string;
-                    }
-                ] | [
-                    'state constraint',
-                    {
-                        readonly 'name': string;
-                    }
-                ]>;
-                readonly 'up steps': pt.Array<null>;
-            };
-            namespace Root {
-                namespace numerical__types {
-                    namespace DX { }
-                    type DX = null;
-                }
-                type numerical__types = pt.Dictionary<null>;
-                type root = D.Node;
-            }
-            type Root = {
-                readonly 'numerical types': pt.Dictionary<null>;
-                readonly 'root': D.Node;
-            };
-        }
-        namespace I { }
-        namespace A { }
-    }
-    namespace tendril {
-        namespace G { }
-        namespace N {
-            namespace Atom {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace _$ltype {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Dictionary_$_$Constraints {
-                namespace N {
-                    namespace DX {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace _$ltype {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Global_$_$Type {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace _$ltype {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Global_$_$Type_$_$Selection {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace _$limport {
-                                namespace N {
-                                    namespace O {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace _$ltype {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Imports {
-                namespace N {
-                    namespace DX {
-                        namespace N {
-                            namespace G {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Labels {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace atom_$_$types {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Model {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace root {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace type_$_$library {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Option_$_$Constraints {
-                namespace N {
-                    namespace DX {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace option {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace _$ltype {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Properties {
-                namespace N {
-                    namespace DX {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace _$ltype {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace _$ltype {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace array {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace _$ltype {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace component {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace context {
-                                                                namespace N {
-                                                                    namespace TU {
-                                                                        namespace N {
-                                                                            namespace cyclic_$_$sibling {
-                                                                                namespace N {
-                                                                                    namespace G {
-                                                                                        namespace N {
-                                                                                            namespace _$ltype {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace _$limport {
-                                                                                namespace N {
-                                                                                    namespace G {
-                                                                                        namespace N {
-                                                                                            namespace library {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                            namespace _$ltype {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace resolved_$_$sibling {
-                                                                                namespace N {
-                                                                                    namespace G {
-                                                                                        namespace N {
-                                                                                            namespace _$ltype {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace dictionary {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace constraints {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace key {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace _$ltype {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace group {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace properties {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace nothing {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace optional {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace _$ltype {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace tagged_$_$union {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace options {
-                                                                namespace N {
-                                                                    namespace DX {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace constraints {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace _$ltype {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace terminal {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace constraint {
-                                                                namespace N {
-                                                                    namespace O {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$ltype {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace terminal {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$_$Library {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace global_$_$types {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace imports {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace labels {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$_$Selection {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace global_$_$type {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace tail {
-                                namespace N {
-                                    namespace O {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$_$Selection_$_$Tail {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace step_$_$type {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace array {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace dictionary {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace group {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace property {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace optional {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace tagged_$_$union {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace option {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace tail {
-                                namespace N {
-                                    namespace O {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D {
-            namespace Atom {
-                type _ltype = string;
-            }
-            type Atom = {
-                readonly 'type': string;
-            };
-            namespace Dictionary__Constraints {
-                namespace DX {
-                    type _ltype = D.Type__Selection;
-                }
-                type DX = {
-                    readonly 'type': D.Type__Selection;
-                };
-            }
-            type Dictionary__Constraints = pt.Dictionary<{
-                readonly 'type': D.Type__Selection;
-            }>;
-            namespace Global__Type {
-                type _ltype = D.Type;
-            }
-            type Global__Type = {
-                readonly 'type': D.Type;
-            };
-            namespace Global__Type__Selection {
-                namespace _limport {
-                    type O = string;
-                }
-                type _limport = pt.OptionalValue<string>;
-                type _ltype = string;
-            }
-            type Global__Type__Selection = {
-                readonly 'import': pt.OptionalValue<string>;
-                readonly 'type': string;
-            };
-            namespace Imports {
-                namespace DX { }
-                type DX = null;
-            }
-            type Imports = pt.Dictionary<null>;
-            namespace Labels {
-                namespace atom__types {
-                    namespace DX { }
-                    type DX = null;
-                }
-                type atom__types = pt.Dictionary<null>;
-            }
-            type Labels = {
-                readonly 'atom types': pt.Dictionary<null>;
-            };
-            namespace Model {
-                type root = string;
-                type type__library = D.Type__Library;
-            }
-            type Model = {
-                readonly 'root': string;
-                readonly 'type library': D.Type__Library;
-            };
-            namespace Option__Constraints {
-                namespace DX {
-                    type option = string;
-                    type _ltype = D.Type__Selection;
-                }
-                type DX = {
-                    readonly 'option': string;
-                    readonly 'type': D.Type__Selection;
-                };
-            }
-            type Option__Constraints = pt.Dictionary<{
-                readonly 'option': string;
-                readonly 'type': D.Type__Selection;
-            }>;
-            namespace Properties {
-                namespace DX {
-                    type _ltype = D.Type;
-                }
-                type DX = {
-                    readonly 'type': D.Type;
-                };
-            }
-            type Properties = pt.Dictionary<{
-                readonly 'type': D.Type;
-            }>;
-            namespace Type {
-                namespace _ltype {
-                    namespace array {
-                        type _ltype = D.Type;
-                    }
-                    type array = {
-                        readonly 'type': D.Type;
-                    };
-                    namespace component {
-                        namespace context {
-                            namespace cyclic__sibling {
-                                type _ltype = string;
-                            }
-                            type cyclic__sibling = {
-                                readonly 'type': string;
-                            };
-                            namespace _limport {
-                                type library = string;
-                                type _ltype = string;
-                            }
-                            type _limport = {
-                                readonly 'library': string;
-                                readonly 'type': string;
-                            };
-                            namespace resolved__sibling {
-                                type _ltype = string;
-                            }
-                            type resolved__sibling = {
-                                readonly 'type': string;
-                            };
-                        }
-                        type context = [
-                            'cyclic sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'import',
-                            {
-                                readonly 'library': string;
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'resolved sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ];
-                    }
-                    type component = {
-                        readonly 'context': [
-                            'cyclic sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'import',
-                            {
-                                readonly 'library': string;
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'resolved sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ];
-                    };
-                    namespace dictionary {
-                        type constraints = D.Dictionary__Constraints;
-                        type key = D.Atom;
-                        type _ltype = D.Type;
-                    }
-                    type dictionary = {
-                        readonly 'constraints': D.Dictionary__Constraints;
-                        readonly 'key': D.Atom;
-                        readonly 'type': D.Type;
-                    };
-                    namespace group {
-                        type properties = D.Properties;
-                    }
-                    type group = {
-                        readonly 'properties': D.Properties;
-                    };
-                    namespace nothing { }
-                    type nothing = null;
-                    namespace optional {
-                        type _ltype = D.Type;
-                    }
-                    type optional = {
-                        readonly 'type': D.Type;
-                    };
-                    namespace tagged__union {
-                        namespace options {
-                            namespace DX {
-                                type constraints = D.Option__Constraints;
-                                type _ltype = D.Type;
-                            }
-                            type DX = {
-                                readonly 'constraints': D.Option__Constraints;
-                                readonly 'type': D.Type;
-                            };
-                        }
-                        type options = pt.Dictionary<{
-                            readonly 'constraints': D.Option__Constraints;
-                            readonly 'type': D.Type;
-                        }>;
-                    }
-                    type tagged__union = {
-                        readonly 'options': pt.Dictionary<{
-                            readonly 'constraints': D.Option__Constraints;
-                            readonly 'type': D.Type;
-                        }>;
-                    };
-                    namespace terminal {
-                        namespace constraint {
-                            namespace O {
-                                type _ltype = D.Type__Selection;
-                            }
-                            type O = {
-                                readonly 'type': D.Type__Selection;
-                            };
-                        }
-                        type constraint = pt.OptionalValue<{
-                            readonly 'type': D.Type__Selection;
-                        }>;
-                        type terminal = D.Atom;
-                    }
-                    type terminal = {
-                        readonly 'constraint': pt.OptionalValue<{
-                            readonly 'type': D.Type__Selection;
-                        }>;
-                        readonly 'terminal': D.Atom;
-                    };
-                }
-                type _ltype = [
-                    'array',
-                    {
-                        readonly 'type': D.Type;
-                    }
-                ] | [
-                    'component',
-                    {
-                        readonly 'context': [
-                            'cyclic sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'import',
-                            {
-                                readonly 'library': string;
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'resolved sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ];
-                    }
-                ] | [
-                    'dictionary',
-                    {
-                        readonly 'constraints': D.Dictionary__Constraints;
-                        readonly 'key': D.Atom;
-                        readonly 'type': D.Type;
-                    }
-                ] | [
-                    'group',
-                    {
-                        readonly 'properties': D.Properties;
-                    }
-                ] | ['nothing', null] | [
-                    'optional',
-                    {
-                        readonly 'type': D.Type;
-                    }
-                ] | [
-                    'tagged union',
-                    {
-                        readonly 'options': pt.Dictionary<{
-                            readonly 'constraints': D.Option__Constraints;
-                            readonly 'type': D.Type;
-                        }>;
-                    }
-                ] | [
-                    'terminal',
-                    {
-                        readonly 'constraint': pt.OptionalValue<{
-                            readonly 'type': D.Type__Selection;
-                        }>;
-                        readonly 'terminal': D.Atom;
-                    }
-                ];
-            }
-            type Type = {
-                readonly 'type': [
-                    'array',
-                    {
-                        readonly 'type': D.Type;
-                    }
-                ] | [
-                    'component',
-                    {
-                        readonly 'context': [
-                            'cyclic sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'import',
-                            {
-                                readonly 'library': string;
-                                readonly 'type': string;
-                            }
-                        ] | [
-                            'resolved sibling',
-                            {
-                                readonly 'type': string;
-                            }
-                        ];
-                    }
-                ] | [
-                    'dictionary',
-                    {
-                        readonly 'constraints': D.Dictionary__Constraints;
-                        readonly 'key': D.Atom;
-                        readonly 'type': D.Type;
-                    }
-                ] | [
-                    'group',
-                    {
-                        readonly 'properties': D.Properties;
-                    }
-                ] | ['nothing', null] | [
-                    'optional',
-                    {
-                        readonly 'type': D.Type;
-                    }
-                ] | [
-                    'tagged union',
-                    {
-                        readonly 'options': pt.Dictionary<{
-                            readonly 'constraints': D.Option__Constraints;
-                            readonly 'type': D.Type;
-                        }>;
-                    }
-                ] | [
-                    'terminal',
-                    {
-                        readonly 'constraint': pt.OptionalValue<{
-                            readonly 'type': D.Type__Selection;
-                        }>;
-                        readonly 'terminal': D.Atom;
-                    }
-                ];
-            };
-            namespace Type__Library {
-                namespace global__types {
-                    type DX = D.Global__Type;
-                }
-                type global__types = pt.Dictionary<D.Global__Type>;
-                type imports = D.Imports;
-                type labels = D.Labels;
-            }
-            type Type__Library = {
-                readonly 'global types': pt.Dictionary<D.Global__Type>;
-                readonly 'imports': D.Imports;
-                readonly 'labels': D.Labels;
-            };
-            namespace Type__Selection {
-                type global__type = D.Global__Type__Selection;
-                namespace tail {
-                    type O = D.Type__Selection__Tail;
-                }
-                type tail = pt.OptionalValue<D.Type__Selection__Tail>;
-            }
-            type Type__Selection = {
-                readonly 'global type': D.Global__Type__Selection;
-                readonly 'tail': pt.OptionalValue<D.Type__Selection__Tail>;
-            };
-            namespace Type__Selection__Tail {
-                namespace step__type {
-                    namespace array { }
-                    type array = null;
-                    namespace dictionary { }
-                    type dictionary = null;
-                    namespace group {
-                        type property = string;
-                    }
-                    type group = {
-                        readonly 'property': string;
-                    };
-                    namespace optional { }
-                    type optional = null;
-                    namespace tagged__union {
-                        type option = string;
-                    }
-                    type tagged__union = {
-                        readonly 'option': string;
-                    };
-                }
-                type step__type = ['array', null] | ['dictionary', null] | [
-                    'group',
-                    {
-                        readonly 'property': string;
-                    }
-                ] | ['optional', null] | [
-                    'tagged union',
-                    {
-                        readonly 'option': string;
-                    }
-                ];
-                namespace tail {
-                    type O = D.Type__Selection__Tail;
-                }
-                type tail = pt.OptionalValue<D.Type__Selection__Tail>;
-            }
-            type Type__Selection__Tail = {
-                readonly 'step type': ['array', null] | ['dictionary', null] | [
-                    'group',
-                    {
-                        readonly 'property': string;
-                    }
-                ] | ['optional', null] | [
-                    'tagged union',
-                    {
-                        readonly 'option': string;
-                    }
-                ];
-                readonly 'tail': pt.OptionalValue<D.Type__Selection__Tail>;
-            };
-        }
-        namespace I { }
-        namespace A { }
-    }
-}
-export declare namespace N { }
-export declare namespace D { }
-export declare namespace I { }
-export declare namespace A {
-    type Map = ($: G.tendril.D.Model) => G.alan__light.D.Root;
-}