pareto 0.56.0 → 0.57.0

package/auto.dist/public/glossaries/tendril.d.ts

@@ -1,1425 +0,0 @@
-import * as pt from 'pareto-core-types';
-export declare namespace G { }
-export declare 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 result {
-                        namespace N {
-                            namespace O {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace _$ltype {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    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 result {
-                                                        namespace N {
-                                                            namespace O {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace _$ltype {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace optional {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace result {
-                                                        namespace N {
-                                                            namespace O {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace _$ltype {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    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 result {
-                                                        namespace N {
-                                                            namespace O {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace terminal {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace constrained {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace no {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace yes {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace computed {
-                                                                                        namespace N {
-                                                                                            namespace TU {
-                                                                                                namespace N {
-                                                                                                    namespace no {
-                                                                                                        namespace N {
-                                                                                                            namespace G {
-                                                                                                                namespace N { }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                        }
-                                                                                                        namespace D { }
-                                                                                                    }
-                                                                                                    namespace yes {
-                                                                                                        namespace N {
-                                                                                                            namespace G {
-                                                                                                                namespace N { }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                        }
-                                                                                                        namespace D { }
-                                                                                                    }
-                                                                                                }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace _$ltype {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                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 { }
-    }
-}
-export declare namespace D {
-    namespace Atom {
-        namespace _ltype {
-            type annotation<GAnnotation> = GAnnotation;
-            type key<GAnnotation> = string;
-        }
-        type _ltype<GAnnotation> = {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-    }
-    type Atom<GAnnotation> = {
-        readonly 'type': {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-    };
-    namespace Dictionary__Constraints {
-        namespace DX {
-            type _ltype<GAnnotation> = D.Type__Selection<GAnnotation>;
-        }
-        type DX<GAnnotation> = {
-            readonly 'type': D.Type__Selection<GAnnotation>;
-        };
-    }
-    type Dictionary__Constraints<GAnnotation> = pt.Dictionary<{
-        readonly 'type': D.Type__Selection<GAnnotation>;
-    }>;
-    namespace Global__Type {
-        namespace result {
-            namespace O {
-                type _ltype<GAnnotation> = D.Global__Type__Selection<GAnnotation>;
-            }
-            type O<GAnnotation> = {
-                readonly 'type': D.Global__Type__Selection<GAnnotation>;
-            };
-        }
-        type result<GAnnotation> = pt.OptionalValue<{
-            readonly 'type': D.Global__Type__Selection<GAnnotation>;
-        }>;
-        type _ltype<GAnnotation> = D.Type<GAnnotation>;
-    }
-    type Global__Type<GAnnotation> = {
-        readonly 'result': pt.OptionalValue<{
-            readonly 'type': D.Global__Type__Selection<GAnnotation>;
-        }>;
-        readonly 'type': D.Type<GAnnotation>;
-    };
-    namespace Global__Type__Selection {
-        namespace _limport {
-            namespace O {
-                type annotation<GAnnotation> = GAnnotation;
-                type key<GAnnotation> = string;
-            }
-            type O<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'key': string;
-            };
-        }
-        type _limport<GAnnotation> = pt.OptionalValue<{
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        }>;
-        namespace _ltype {
-            type annotation<GAnnotation> = GAnnotation;
-            type key<GAnnotation> = string;
-        }
-        type _ltype<GAnnotation> = {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-    }
-    type Global__Type__Selection<GAnnotation> = {
-        readonly 'import': pt.OptionalValue<{
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        }>;
-        readonly 'type': {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-    };
-    namespace Imports {
-        namespace DX { }
-        type DX<GAnnotation> = null;
-    }
-    type Imports<GAnnotation> = pt.Dictionary<null>;
-    namespace Labels {
-        namespace atom__types {
-            namespace DX { }
-            type DX<GAnnotation> = null;
-        }
-        type atom__types<GAnnotation> = pt.Dictionary<null>;
-    }
-    type Labels<GAnnotation> = {
-        readonly 'atom types': pt.Dictionary<null>;
-    };
-    namespace Model {
-        namespace root {
-            type annotation<GAnnotation> = GAnnotation;
-            type key<GAnnotation> = string;
-        }
-        type root<GAnnotation> = {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-        type type__library<GAnnotation> = D.Type__Library<GAnnotation>;
-    }
-    type Model<GAnnotation> = {
-        readonly 'root': {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-        readonly 'type library': D.Type__Library<GAnnotation>;
-    };
-    namespace Option__Constraints {
-        namespace DX {
-            namespace option {
-                type annotation<GAnnotation> = GAnnotation;
-                type key<GAnnotation> = string;
-            }
-            type option<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'key': string;
-            };
-            type _ltype<GAnnotation> = D.Type__Selection<GAnnotation>;
-        }
-        type DX<GAnnotation> = {
-            readonly 'option': {
-                readonly 'annotation': GAnnotation;
-                readonly 'key': string;
-            };
-            readonly 'type': D.Type__Selection<GAnnotation>;
-        };
-    }
-    type Option__Constraints<GAnnotation> = pt.Dictionary<{
-        readonly 'option': {
-            readonly 'annotation': GAnnotation;
-            readonly 'key': string;
-        };
-        readonly 'type': D.Type__Selection<GAnnotation>;
-    }>;
-    namespace Properties {
-        namespace DX {
-            type _ltype<GAnnotation> = D.Type<GAnnotation>;
-        }
-        type DX<GAnnotation> = {
-            readonly 'type': D.Type<GAnnotation>;
-        };
-    }
-    type Properties<GAnnotation> = pt.Dictionary<{
-        readonly 'type': D.Type<GAnnotation>;
-    }>;
-    namespace Type {
-        namespace _ltype {
-            namespace array {
-                type _ltype<GAnnotation> = D.Type<GAnnotation>;
-            }
-            type array<GAnnotation> = {
-                readonly 'type': D.Type<GAnnotation>;
-            };
-            namespace component {
-                namespace context {
-                    namespace cyclic__sibling {
-                        namespace _ltype {
-                            type annotation<GAnnotation> = GAnnotation;
-                            type key<GAnnotation> = string;
-                        }
-                        type _ltype<GAnnotation> = {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                    type cyclic__sibling<GAnnotation> = {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    };
-                    namespace _limport {
-                        namespace library {
-                            type annotation<GAnnotation> = GAnnotation;
-                            type key<GAnnotation> = string;
-                        }
-                        type library<GAnnotation> = {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                        namespace _ltype {
-                            type annotation<GAnnotation> = GAnnotation;
-                            type key<GAnnotation> = string;
-                        }
-                        type _ltype<GAnnotation> = {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                    type _limport<GAnnotation> = {
-                        readonly 'library': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    };
-                    namespace resolved__sibling {
-                        namespace _ltype {
-                            type annotation<GAnnotation> = GAnnotation;
-                            type key<GAnnotation> = string;
-                        }
-                        type _ltype<GAnnotation> = {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                    type resolved__sibling<GAnnotation> = {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    };
-                }
-                type context<GAnnotation> = [
-                    'cyclic sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'import',
-                    {
-                        readonly 'library': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'resolved sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ];
-            }
-            type component<GAnnotation> = {
-                readonly 'context': [
-                    'cyclic sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'import',
-                    {
-                        readonly 'library': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'resolved sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ];
-            };
-            namespace dictionary {
-                type constraints<GAnnotation> = D.Dictionary__Constraints<GAnnotation>;
-                type key<GAnnotation> = D.Atom<GAnnotation>;
-                type _ltype<GAnnotation> = D.Type<GAnnotation>;
-            }
-            type dictionary<GAnnotation> = {
-                readonly 'constraints': D.Dictionary__Constraints<GAnnotation>;
-                readonly 'key': D.Atom<GAnnotation>;
-                readonly 'type': D.Type<GAnnotation>;
-            };
-            namespace group {
-                type properties<GAnnotation> = D.Properties<GAnnotation>;
-            }
-            type group<GAnnotation> = {
-                readonly 'properties': D.Properties<GAnnotation>;
-            };
-            namespace nothing {
-                namespace result {
-                    namespace O {
-                        type _ltype<GAnnotation> = D.Global__Type__Selection<GAnnotation>;
-                    }
-                    type O<GAnnotation> = {
-                        readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                    };
-                }
-                type result<GAnnotation> = pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-            }
-            type nothing<GAnnotation> = {
-                readonly 'result': pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-            };
-            namespace optional {
-                namespace result {
-                    namespace O {
-                        type _ltype<GAnnotation> = D.Global__Type__Selection<GAnnotation>;
-                    }
-                    type O<GAnnotation> = {
-                        readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                    };
-                }
-                type result<GAnnotation> = pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-                type _ltype<GAnnotation> = D.Type<GAnnotation>;
-            }
-            type optional<GAnnotation> = {
-                readonly 'result': pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-                readonly 'type': D.Type<GAnnotation>;
-            };
-            namespace tagged__union {
-                namespace options {
-                    namespace DX {
-                        type constraints<GAnnotation> = D.Option__Constraints<GAnnotation>;
-                        type _ltype<GAnnotation> = D.Type<GAnnotation>;
-                    }
-                    type DX<GAnnotation> = {
-                        readonly 'constraints': D.Option__Constraints<GAnnotation>;
-                        readonly 'type': D.Type<GAnnotation>;
-                    };
-                }
-                type options<GAnnotation> = pt.Dictionary<{
-                    readonly 'constraints': D.Option__Constraints<GAnnotation>;
-                    readonly 'type': D.Type<GAnnotation>;
-                }>;
-                namespace result {
-                    type O<GAnnotation> = D.Global__Type__Selection<GAnnotation>;
-                }
-                type result<GAnnotation> = pt.OptionalValue<D.Global__Type__Selection<GAnnotation>>;
-            }
-            type tagged__union<GAnnotation> = {
-                readonly 'options': pt.Dictionary<{
-                    readonly 'constraints': D.Option__Constraints<GAnnotation>;
-                    readonly 'type': D.Type<GAnnotation>;
-                }>;
-                readonly 'result': pt.OptionalValue<D.Global__Type__Selection<GAnnotation>>;
-            };
-            namespace terminal {
-                namespace constrained {
-                    namespace no { }
-                    type no<GAnnotation> = null;
-                    namespace yes {
-                        namespace computed {
-                            namespace no { }
-                            type no<GAnnotation> = null;
-                            namespace yes { }
-                            type yes<GAnnotation> = null;
-                        }
-                        type computed<GAnnotation> = ['no', null] | ['yes', null];
-                        type _ltype<GAnnotation> = D.Type__Selection<GAnnotation>;
-                    }
-                    type yes<GAnnotation> = {
-                        readonly 'computed': ['no', null] | ['yes', null];
-                        readonly 'type': D.Type__Selection<GAnnotation>;
-                    };
-                }
-                type constrained<GAnnotation> = ['no', null] | [
-                    'yes',
-                    {
-                        readonly 'computed': ['no', null] | ['yes', null];
-                        readonly 'type': D.Type__Selection<GAnnotation>;
-                    }
-                ];
-                type terminal<GAnnotation> = D.Atom<GAnnotation>;
-            }
-            type terminal<GAnnotation> = {
-                readonly 'constrained': ['no', null] | [
-                    'yes',
-                    {
-                        readonly 'computed': ['no', null] | ['yes', null];
-                        readonly 'type': D.Type__Selection<GAnnotation>;
-                    }
-                ];
-                readonly 'terminal': D.Atom<GAnnotation>;
-            };
-        }
-        type _ltype<GAnnotation> = [
-            'array',
-            {
-                readonly 'type': D.Type<GAnnotation>;
-            }
-        ] | [
-            'component',
-            {
-                readonly 'context': [
-                    'cyclic sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'import',
-                    {
-                        readonly 'library': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'resolved sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ];
-            }
-        ] | [
-            'dictionary',
-            {
-                readonly 'constraints': D.Dictionary__Constraints<GAnnotation>;
-                readonly 'key': D.Atom<GAnnotation>;
-                readonly 'type': D.Type<GAnnotation>;
-            }
-        ] | [
-            'group',
-            {
-                readonly 'properties': D.Properties<GAnnotation>;
-            }
-        ] | [
-            'nothing',
-            {
-                readonly 'result': pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-            }
-        ] | [
-            'optional',
-            {
-                readonly 'result': pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-                readonly 'type': D.Type<GAnnotation>;
-            }
-        ] | [
-            'tagged union',
-            {
-                readonly 'options': pt.Dictionary<{
-                    readonly 'constraints': D.Option__Constraints<GAnnotation>;
-                    readonly 'type': D.Type<GAnnotation>;
-                }>;
-                readonly 'result': pt.OptionalValue<D.Global__Type__Selection<GAnnotation>>;
-            }
-        ] | [
-            'terminal',
-            {
-                readonly 'constrained': ['no', null] | [
-                    'yes',
-                    {
-                        readonly 'computed': ['no', null] | ['yes', null];
-                        readonly 'type': D.Type__Selection<GAnnotation>;
-                    }
-                ];
-                readonly 'terminal': D.Atom<GAnnotation>;
-            }
-        ];
-    }
-    type Type<GAnnotation> = {
-        readonly 'type': [
-            'array',
-            {
-                readonly 'type': D.Type<GAnnotation>;
-            }
-        ] | [
-            'component',
-            {
-                readonly 'context': [
-                    'cyclic sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'import',
-                    {
-                        readonly 'library': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ] | [
-                    'resolved sibling',
-                    {
-                        readonly 'type': {
-                            readonly 'annotation': GAnnotation;
-                            readonly 'key': string;
-                        };
-                    }
-                ];
-            }
-        ] | [
-            'dictionary',
-            {
-                readonly 'constraints': D.Dictionary__Constraints<GAnnotation>;
-                readonly 'key': D.Atom<GAnnotation>;
-                readonly 'type': D.Type<GAnnotation>;
-            }
-        ] | [
-            'group',
-            {
-                readonly 'properties': D.Properties<GAnnotation>;
-            }
-        ] | [
-            'nothing',
-            {
-                readonly 'result': pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-            }
-        ] | [
-            'optional',
-            {
-                readonly 'result': pt.OptionalValue<{
-                    readonly 'type': D.Global__Type__Selection<GAnnotation>;
-                }>;
-                readonly 'type': D.Type<GAnnotation>;
-            }
-        ] | [
-            'tagged union',
-            {
-                readonly 'options': pt.Dictionary<{
-                    readonly 'constraints': D.Option__Constraints<GAnnotation>;
-                    readonly 'type': D.Type<GAnnotation>;
-                }>;
-                readonly 'result': pt.OptionalValue<D.Global__Type__Selection<GAnnotation>>;
-            }
-        ] | [
-            'terminal',
-            {
-                readonly 'constrained': ['no', null] | [
-                    'yes',
-                    {
-                        readonly 'computed': ['no', null] | ['yes', null];
-                        readonly 'type': D.Type__Selection<GAnnotation>;
-                    }
-                ];
-                readonly 'terminal': D.Atom<GAnnotation>;
-            }
-        ];
-    };
-    namespace Type__Library {
-        namespace global__types {
-            type DX<GAnnotation> = D.Global__Type<GAnnotation>;
-        }
-        type global__types<GAnnotation> = pt.Dictionary<D.Global__Type<GAnnotation>>;
-        type imports<GAnnotation> = D.Imports<GAnnotation>;
-        type labels<GAnnotation> = D.Labels<GAnnotation>;
-    }
-    type Type__Library<GAnnotation> = {
-        readonly 'global types': pt.Dictionary<D.Global__Type<GAnnotation>>;
-        readonly 'imports': D.Imports<GAnnotation>;
-        readonly 'labels': D.Labels<GAnnotation>;
-    };
-    namespace Type__Selection {
-        type global__type<GAnnotation> = D.Global__Type__Selection<GAnnotation>;
-        namespace tail {
-            type O<GAnnotation> = D.Type__Selection__Tail<GAnnotation>;
-        }
-        type tail<GAnnotation> = pt.OptionalValue<D.Type__Selection__Tail<GAnnotation>>;
-    }
-    type Type__Selection<GAnnotation> = {
-        readonly 'global type': D.Global__Type__Selection<GAnnotation>;
-        readonly 'tail': pt.OptionalValue<D.Type__Selection__Tail<GAnnotation>>;
-    };
-    namespace Type__Selection__Tail {
-        namespace step__type {
-            namespace array {
-                type annotation<GAnnotation> = GAnnotation;
-                namespace content { }
-                type content<GAnnotation> = null;
-            }
-            type array<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            };
-            namespace dictionary {
-                type annotation<GAnnotation> = GAnnotation;
-                namespace content { }
-                type content<GAnnotation> = null;
-            }
-            type dictionary<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            };
-            namespace group {
-                type annotation<GAnnotation> = GAnnotation;
-                namespace content {
-                    namespace property {
-                        type annotation<GAnnotation> = GAnnotation;
-                        type key<GAnnotation> = string;
-                    }
-                    type property<GAnnotation> = {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                }
-                type content<GAnnotation> = {
-                    readonly 'property': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            }
-            type group<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': {
-                    readonly 'property': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            };
-            namespace optional {
-                type annotation<GAnnotation> = GAnnotation;
-                namespace content { }
-                type content<GAnnotation> = null;
-            }
-            type optional<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            };
-            namespace tagged__union {
-                type annotation<GAnnotation> = GAnnotation;
-                namespace content {
-                    namespace option {
-                        type annotation<GAnnotation> = GAnnotation;
-                        type key<GAnnotation> = string;
-                    }
-                    type option<GAnnotation> = {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                }
-                type content<GAnnotation> = {
-                    readonly 'option': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            }
-            type tagged__union<GAnnotation> = {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': {
-                    readonly 'option': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            };
-        }
-        type step__type<GAnnotation> = [
-            'array',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            }
-        ] | [
-            'dictionary',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            }
-        ] | [
-            'group',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': {
-                    readonly 'property': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            }
-        ] | [
-            'optional',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            }
-        ] | [
-            'tagged union',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': {
-                    readonly 'option': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            }
-        ];
-        namespace tail {
-            type O<GAnnotation> = D.Type__Selection__Tail<GAnnotation>;
-        }
-        type tail<GAnnotation> = pt.OptionalValue<D.Type__Selection__Tail<GAnnotation>>;
-    }
-    type Type__Selection__Tail<GAnnotation> = {
-        readonly 'step type': [
-            'array',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            }
-        ] | [
-            'dictionary',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            }
-        ] | [
-            'group',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': {
-                    readonly 'property': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            }
-        ] | [
-            'optional',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': null;
-            }
-        ] | [
-            'tagged union',
-            {
-                readonly 'annotation': GAnnotation;
-                readonly 'content': {
-                    readonly 'option': {
-                        readonly 'annotation': GAnnotation;
-                        readonly 'key': string;
-                    };
-                };
-            }
-        ];
-        readonly 'tail': pt.OptionalValue<D.Type__Selection__Tail<GAnnotation>>;
-    };
-}
-export declare namespace I { }
-export declare namespace A { }