pareto 0.56.0 → 0.57.0

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

@@ -1,1503 +0,0 @@
-import * as pt from 'pareto-core-types';
-export declare namespace G { }
-export declare namespace N {
-    namespace Compilation_$_$Unit {
-        namespace N {
-            namespace G {
-                namespace N {
-                    namespace imports {
-                        namespace N {
-                            namespace DX {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace path {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace root_$_$namespace {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Expression {
-        namespace N {
-            namespace TU {
-                namespace N {
-                    namespace flow {
-                        namespace N {
-                            namespace TU {
-                                namespace N {
-                                    namespace block {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace change_$_$context {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace new_$_$context_$_$selection {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace sub_$_$expression {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace implement_$_$me {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace panic {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace literal {
-                        namespace N {
-                            namespace TU {
-                                namespace N {
-                                    namespace array {
-                                        namespace N {
-                                            namespace A {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace _$lboolean {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace _$lfalse {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$ltrue {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace dictionary {
-                                        namespace N {
-                                            namespace DX {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace _$lfunction {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace block {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace temp_$_$signature_$_$help {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace has_$_$additional_$_$parameters {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace has_$_$no_$_$additional_$_$parameters {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace typed {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace group {
-                                        namespace N {
-                                            namespace DX {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace _$lnull {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace _$lnumber {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace optional {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace not_$_$set {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$lset {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace _$lstring {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace tagged_$_$union {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace data {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace state {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace map {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace selection {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace _$ltype {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace array {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$lboolean {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace false_$_$expression {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace true_$_$expression {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace dictionary {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace optional {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace not_$_$set {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace _$lset {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace tagged_$_$union {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace cases {
-                                                                        namespace N {
-                                                                            namespace DX {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace _$ldefault {
-                                                                        namespace N {
-                                                                            namespace O {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace reduce {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace callback {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace initial {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace selection {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace selection {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace start {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace context {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace parameter {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace seed {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace variable {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace _$limport {
-                                                                        namespace N {
-                                                                            namespace O {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace namespace_$_$path {
-                                                                        namespace N {
-                                                                            namespace A {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace variable {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace tail {
-                                        namespace N {
-                                            namespace A {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace call {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace _$larguments {
-                                                                                namespace N {
-                                                                                    namespace DX {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace context {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace type_$_$arguments {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace member_$_$selection {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Function_$_$Signature {
-        namespace N {
-            namespace G {
-                namespace N {
-                    namespace context_$_$parameter {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace parameters {
-                        namespace N {
-                            namespace DX {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace return_$_$type {
-                        namespace N {
-                            namespace O {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace type_$_$parameters {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Namespace {
-        namespace N {
-            namespace G {
-                namespace N {
-                    namespace namespaces {
-                        namespace N {
-                            namespace DX {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace types {
-                        namespace N {
-                            namespace DX {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace _$ltype {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace type_$_$parameters {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace variables {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Statement_$_$Block {
-        namespace N {
-            namespace G {
-                namespace N {
-                    namespace statements {
-                        namespace N {
-                            namespace A {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace assignment {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace expression {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace selection {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace change_$_$context {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace new_$_$context_$_$selection {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace sub_$_$statement_$_$block {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace debug {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace expression {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace _$lif {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace condition {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace _$lelse {
-                                                                namespace N {
-                                                                    namespace O {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace if_$_$block {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$lreturn {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace expression {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace sub_$_$block {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace _$lswitch {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace cases {
-                                                                namespace N {
-                                                                    namespace DX {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace _$ldefault {
-                                                                namespace N {
-                                                                    namespace O {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace select {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace variables {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Type {
-        namespace N {
-            namespace TU {
-                namespace N {
-                    namespace array {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace _$lboolean {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace dictionary {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace _$lfunction {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace group {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace members {
-                                        namespace N {
-                                            namespace DX {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace _$lnull {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace _$lnumber {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace optional {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace parameter_$_$selection {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace _$lstring {
-                        namespace N { }
-                        namespace D { }
-                    }
-                    namespace tagged_$_$union {
-                        namespace N {
-                            namespace DX {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                    namespace type_$_$selection {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace _$limport {
-                                        namespace N {
-                                            namespace O {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace namespace_$_$path {
-                                        namespace N {
-                                            namespace A {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                    namespace _$ltype {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace type_$_$arguments {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Type_$_$Arguments {
-        namespace N {
-            namespace DX {
-                namespace N { }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Type_$_$Parameters {
-        namespace N {
-            namespace DX {
-                namespace N { }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-    namespace Variables {
-        namespace N {
-            namespace DX {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace expression {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace mutable {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$ltype {
-                                namespace N {
-                                    namespace O {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D { }
-    }
-}
-export declare namespace D {
-    namespace Compilation__Unit {
-        namespace imports {
-            namespace DX {
-                type path = string;
-            }
-            type DX = {
-                readonly 'path': string;
-            };
-        }
-        type imports = pt.Dictionary<{
-            readonly 'path': string;
-        }>;
-        type root__namespace = D.Namespace;
-    }
-    type Compilation__Unit = {
-        readonly 'imports': pt.Dictionary<{
-            readonly 'path': string;
-        }>;
-        readonly 'root namespace': D.Namespace;
-    };
-    namespace Expression {
-        namespace flow {
-            type block = D.Statement__Block;
-            namespace change__context {
-                type new__context__selection = D.Expression;
-                type sub__expression = D.Expression;
-            }
-            type change__context = {
-                readonly 'new context selection': D.Expression;
-                readonly 'sub expression': D.Expression;
-            };
-            type implement__me = string;
-            type panic = string;
-        }
-        type flow = ['block', D.Statement__Block] | [
-            'change context',
-            {
-                readonly 'new context selection': D.Expression;
-                readonly 'sub expression': D.Expression;
-            }
-        ] | ['implement me', string] | ['panic', string];
-        namespace literal {
-            namespace array {
-                type A = D.Expression;
-            }
-            type array = pt.Array<D.Expression>;
-            namespace _lboolean {
-                type _lfalse = null;
-                type _ltrue = null;
-            }
-            type _lboolean = ['false', null] | ['true', null];
-            namespace dictionary {
-                type DX = D.Expression;
-            }
-            type dictionary = pt.Dictionary<D.Expression>;
-            namespace _lfunction {
-                type block = D.Statement__Block;
-                namespace temp__signature__help {
-                    type has__additional__parameters = null;
-                    type has__no__additional__parameters = null;
-                    type typed = D.Function__Signature;
-                }
-                type temp__signature__help = ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-            }
-            type _lfunction = {
-                readonly 'block': D.Statement__Block;
-                readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-            };
-            namespace group {
-                type DX = D.Expression;
-            }
-            type group = pt.Dictionary<D.Expression>;
-            type _lnull = null;
-            type _lnumber = number;
-            namespace optional {
-                type not__set = null;
-                type _lset = D.Expression;
-            }
-            type optional = ['not set', null] | ['set', D.Expression];
-            type _lstring = string;
-            namespace tagged__union {
-                type data = D.Expression;
-                type state = string;
-            }
-            type tagged__union = {
-                readonly 'data': D.Expression;
-                readonly 'state': string;
-            };
-        }
-        type literal = ['array', pt.Array<D.Expression>] | [
-            'boolean',
-            ['false', null] | ['true', null]
-        ] | ['dictionary', pt.Dictionary<D.Expression>] | [
-            'function',
-            {
-                readonly 'block': D.Statement__Block;
-                readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-            }
-        ] | ['group', pt.Dictionary<D.Expression>] | ['null', null] | ['number', number] | [
-            'optional',
-            ['not set', null] | ['set', D.Expression]
-        ] | ['string', string] | [
-            'tagged union',
-            {
-                readonly 'data': D.Expression;
-                readonly 'state': string;
-            }
-        ];
-        namespace map {
-            type selection = D.Expression;
-            namespace _ltype {
-                type array = D.Expression;
-                namespace _lboolean {
-                    type false__expression = D.Expression;
-                    type true__expression = D.Expression;
-                }
-                type _lboolean = {
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                };
-                type dictionary = D.Expression;
-                namespace optional {
-                    type not__set = D.Expression;
-                    type _lset = D.Expression;
-                }
-                type optional = {
-                    readonly 'not set': D.Expression;
-                    readonly 'set': D.Expression;
-                };
-                namespace tagged__union {
-                    namespace cases {
-                        type DX = D.Expression;
-                    }
-                    type cases = pt.Dictionary<D.Expression>;
-                    namespace _ldefault {
-                        type O = D.Expression;
-                    }
-                    type _ldefault = pt.OptionalValue<D.Expression>;
-                }
-                type tagged__union = {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                };
-            }
-            type _ltype = ['array', D.Expression] | [
-                'boolean',
-                {
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                }
-            ] | ['dictionary', D.Expression] | [
-                'optional',
-                {
-                    readonly 'not set': D.Expression;
-                    readonly 'set': D.Expression;
-                }
-            ] | [
-                'tagged union',
-                {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                }
-            ];
-        }
-        type map = {
-            readonly 'selection': D.Expression;
-            readonly 'type': ['array', D.Expression] | [
-                'boolean',
-                {
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                }
-            ] | ['dictionary', D.Expression] | [
-                'optional',
-                {
-                    readonly 'not set': D.Expression;
-                    readonly 'set': D.Expression;
-                }
-            ] | [
-                'tagged union',
-                {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                }
-            ];
-        };
-        namespace reduce {
-            type callback = D.Expression;
-            type initial = D.Expression;
-            type selection = D.Expression;
-        }
-        type reduce = {
-            readonly 'callback': D.Expression;
-            readonly 'initial': D.Expression;
-            readonly 'selection': D.Expression;
-        };
-        namespace selection {
-            namespace start {
-                type context = null;
-                type parameter = string;
-                type seed = null;
-                namespace variable {
-                    namespace _limport {
-                        type O = string;
-                    }
-                    type _limport = pt.OptionalValue<string>;
-                    namespace namespace__path {
-                        type A = string;
-                    }
-                    type namespace__path = pt.Array<string>;
-                    type variable = string;
-                }
-                type variable = {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'variable': string;
-                };
-            }
-            type start = ['context', null] | ['parameter', string] | ['seed', null] | [
-                'variable',
-                {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'variable': string;
-                }
-            ];
-            namespace tail {
-                namespace A {
-                    namespace call {
-                        namespace _larguments {
-                            type DX = D.Expression;
-                        }
-                        type _larguments = pt.Dictionary<D.Expression>;
-                        type context = D.Expression;
-                        type type__arguments = D.Type__Arguments;
-                    }
-                    type call = {
-                        readonly 'arguments': pt.Dictionary<D.Expression>;
-                        readonly 'context': D.Expression;
-                        readonly 'type arguments': D.Type__Arguments;
-                    };
-                    type member__selection = string;
-                }
-                type A = [
-                    'call',
-                    {
-                        readonly 'arguments': pt.Dictionary<D.Expression>;
-                        readonly 'context': D.Expression;
-                        readonly 'type arguments': D.Type__Arguments;
-                    }
-                ] | ['member selection', string];
-            }
-            type tail = pt.Array<[
-                'call',
-                {
-                    readonly 'arguments': pt.Dictionary<D.Expression>;
-                    readonly 'context': D.Expression;
-                    readonly 'type arguments': D.Type__Arguments;
-                }
-            ] | ['member selection', string]>;
-        }
-        type selection = {
-            readonly 'start': ['context', null] | ['parameter', string] | ['seed', null] | [
-                'variable',
-                {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'variable': string;
-                }
-            ];
-            readonly 'tail': pt.Array<[
-                'call',
-                {
-                    readonly 'arguments': pt.Dictionary<D.Expression>;
-                    readonly 'context': D.Expression;
-                    readonly 'type arguments': D.Type__Arguments;
-                }
-            ] | ['member selection', string]>;
-        };
-    }
-    type Expression = [
-        'flow',
-        ['block', D.Statement__Block] | [
-            'change context',
-            {
-                readonly 'new context selection': D.Expression;
-                readonly 'sub expression': D.Expression;
-            }
-        ] | ['implement me', string] | ['panic', string]
-    ] | [
-        'literal',
-        ['array', pt.Array<D.Expression>] | [
-            'boolean',
-            ['false', null] | ['true', null]
-        ] | ['dictionary', pt.Dictionary<D.Expression>] | [
-            'function',
-            {
-                readonly 'block': D.Statement__Block;
-                readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-            }
-        ] | ['group', pt.Dictionary<D.Expression>] | ['null', null] | ['number', number] | [
-            'optional',
-            ['not set', null] | ['set', D.Expression]
-        ] | ['string', string] | [
-            'tagged union',
-            {
-                readonly 'data': D.Expression;
-                readonly 'state': string;
-            }
-        ]
-    ] | [
-        'map',
-        {
-            readonly 'selection': D.Expression;
-            readonly 'type': ['array', D.Expression] | [
-                'boolean',
-                {
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                }
-            ] | ['dictionary', D.Expression] | [
-                'optional',
-                {
-                    readonly 'not set': D.Expression;
-                    readonly 'set': D.Expression;
-                }
-            ] | [
-                'tagged union',
-                {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                }
-            ];
-        }
-    ] | [
-        'reduce',
-        {
-            readonly 'callback': D.Expression;
-            readonly 'initial': D.Expression;
-            readonly 'selection': D.Expression;
-        }
-    ] | [
-        'selection',
-        {
-            readonly 'start': ['context', null] | ['parameter', string] | ['seed', null] | [
-                'variable',
-                {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'variable': string;
-                }
-            ];
-            readonly 'tail': pt.Array<[
-                'call',
-                {
-                    readonly 'arguments': pt.Dictionary<D.Expression>;
-                    readonly 'context': D.Expression;
-                    readonly 'type arguments': D.Type__Arguments;
-                }
-            ] | ['member selection', string]>;
-        }
-    ];
-    namespace Function__Signature {
-        type context__parameter = D.Type;
-        namespace parameters {
-            type DX = D.Type;
-        }
-        type parameters = pt.Dictionary<D.Type>;
-        namespace return__type {
-            type O = D.Type;
-        }
-        type return__type = pt.OptionalValue<D.Type>;
-        type type__parameters = D.Type__Parameters;
-    }
-    type Function__Signature = {
-        readonly 'context parameter': D.Type;
-        readonly 'parameters': pt.Dictionary<D.Type>;
-        readonly 'return type': pt.OptionalValue<D.Type>;
-        readonly 'type parameters': D.Type__Parameters;
-    };
-    namespace Namespace {
-        namespace namespaces {
-            type DX = D.Namespace;
-        }
-        type namespaces = pt.Dictionary<D.Namespace>;
-        namespace types {
-            namespace DX {
-                type _ltype = D.Type;
-                type type__parameters = D.Type__Parameters;
-            }
-            type DX = {
-                readonly 'type': D.Type;
-                readonly 'type parameters': D.Type__Parameters;
-            };
-        }
-        type types = pt.Dictionary<{
-            readonly 'type': D.Type;
-            readonly 'type parameters': D.Type__Parameters;
-        }>;
-        type variables = D.Variables;
-    }
-    type Namespace = {
-        readonly 'namespaces': pt.Dictionary<D.Namespace>;
-        readonly 'types': pt.Dictionary<{
-            readonly 'type': D.Type;
-            readonly 'type parameters': D.Type__Parameters;
-        }>;
-        readonly 'variables': D.Variables;
-    };
-    namespace Statement__Block {
-        namespace statements {
-            namespace A {
-                namespace assignment {
-                    type expression = D.Expression;
-                    type selection = D.Expression;
-                }
-                type assignment = {
-                    readonly 'expression': D.Expression;
-                    readonly 'selection': D.Expression;
-                };
-                namespace change__context {
-                    type new__context__selection = D.Expression;
-                    type sub__statement__block = D.Statement__Block;
-                }
-                type change__context = {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub statement block': D.Statement__Block;
-                };
-                type debug = string;
-                type expression = D.Expression;
-                namespace _lif {
-                    type condition = D.Expression;
-                    namespace _lelse {
-                        type O = D.Statement__Block;
-                    }
-                    type _lelse = pt.OptionalValue<D.Statement__Block>;
-                    type if__block = D.Statement__Block;
-                }
-                type _lif = {
-                    readonly 'condition': D.Expression;
-                    readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                    readonly 'if block': D.Statement__Block;
-                };
-                namespace _lreturn {
-                    type expression = D.Expression;
-                }
-                type _lreturn = {
-                    readonly 'expression': D.Expression;
-                };
-                type sub__block = D.Statement__Block;
-                namespace _lswitch {
-                    namespace cases {
-                        type DX = D.Statement__Block;
-                    }
-                    type cases = pt.Dictionary<D.Statement__Block>;
-                    namespace _ldefault {
-                        type O = D.Statement__Block;
-                    }
-                    type _ldefault = pt.OptionalValue<D.Statement__Block>;
-                    type select = D.Expression;
-                }
-                type _lswitch = {
-                    readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                    readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                    readonly 'select': D.Expression;
-                };
-            }
-            type A = [
-                'assignment',
-                {
-                    readonly 'expression': D.Expression;
-                    readonly 'selection': D.Expression;
-                }
-            ] | [
-                'change context',
-                {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub statement block': D.Statement__Block;
-                }
-            ] | ['debug', string] | ['expression', D.Expression] | [
-                'if',
-                {
-                    readonly 'condition': D.Expression;
-                    readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                    readonly 'if block': D.Statement__Block;
-                }
-            ] | [
-                'return',
-                {
-                    readonly 'expression': D.Expression;
-                }
-            ] | ['sub block', D.Statement__Block] | [
-                'switch',
-                {
-                    readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                    readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                    readonly 'select': D.Expression;
-                }
-            ];
-        }
-        type statements = pt.Array<[
-            'assignment',
-            {
-                readonly 'expression': D.Expression;
-                readonly 'selection': D.Expression;
-            }
-        ] | [
-            'change context',
-            {
-                readonly 'new context selection': D.Expression;
-                readonly 'sub statement block': D.Statement__Block;
-            }
-        ] | ['debug', string] | ['expression', D.Expression] | [
-            'if',
-            {
-                readonly 'condition': D.Expression;
-                readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                readonly 'if block': D.Statement__Block;
-            }
-        ] | [
-            'return',
-            {
-                readonly 'expression': D.Expression;
-            }
-        ] | ['sub block', D.Statement__Block] | [
-            'switch',
-            {
-                readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                readonly 'select': D.Expression;
-            }
-        ]>;
-        type variables = D.Variables;
-    }
-    type Statement__Block = {
-        readonly 'statements': pt.Array<[
-            'assignment',
-            {
-                readonly 'expression': D.Expression;
-                readonly 'selection': D.Expression;
-            }
-        ] | [
-            'change context',
-            {
-                readonly 'new context selection': D.Expression;
-                readonly 'sub statement block': D.Statement__Block;
-            }
-        ] | ['debug', string] | ['expression', D.Expression] | [
-            'if',
-            {
-                readonly 'condition': D.Expression;
-                readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                readonly 'if block': D.Statement__Block;
-            }
-        ] | [
-            'return',
-            {
-                readonly 'expression': D.Expression;
-            }
-        ] | ['sub block', D.Statement__Block] | [
-            'switch',
-            {
-                readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                readonly 'select': D.Expression;
-            }
-        ]>;
-        readonly 'variables': D.Variables;
-    };
-    namespace Type {
-        type array = D.Type;
-        type _lboolean = null;
-        type dictionary = D.Type;
-        type _lfunction = D.Function__Signature;
-        namespace group {
-            namespace members {
-                type DX = D.Type;
-            }
-            type members = pt.Dictionary<D.Type>;
-        }
-        type group = {
-            readonly 'members': pt.Dictionary<D.Type>;
-        };
-        type _lnull = null;
-        type _lnumber = null;
-        type optional = D.Type;
-        type parameter__selection = string;
-        type _lstring = null;
-        namespace tagged__union {
-            type DX = D.Type;
-        }
-        type tagged__union = pt.Dictionary<D.Type>;
-        namespace type__selection {
-            namespace _limport {
-                type O = string;
-            }
-            type _limport = pt.OptionalValue<string>;
-            namespace namespace__path {
-                type A = string;
-            }
-            type namespace__path = pt.Array<string>;
-            type _ltype = string;
-            type type__arguments = D.Type__Arguments;
-        }
-        type type__selection = {
-            readonly 'import': pt.OptionalValue<string>;
-            readonly 'namespace path': pt.Array<string>;
-            readonly 'type': string;
-            readonly 'type arguments': D.Type__Arguments;
-        };
-    }
-    type Type = ['array', D.Type] | ['boolean', null] | ['dictionary', D.Type] | ['function', D.Function__Signature] | [
-        'group',
-        {
-            readonly 'members': pt.Dictionary<D.Type>;
-        }
-    ] | ['null', null] | ['number', null] | ['optional', D.Type] | ['parameter selection', string] | ['string', null] | ['tagged union', pt.Dictionary<D.Type>] | [
-        'type selection',
-        {
-            readonly 'import': pt.OptionalValue<string>;
-            readonly 'namespace path': pt.Array<string>;
-            readonly 'type': string;
-            readonly 'type arguments': D.Type__Arguments;
-        }
-    ];
-    namespace Type__Arguments {
-        type DX = D.Type;
-    }
-    type Type__Arguments = pt.Dictionary<D.Type>;
-    namespace Type__Parameters {
-        type DX = null;
-    }
-    type Type__Parameters = pt.Dictionary<null>;
-    namespace Variables {
-        namespace DX {
-            type expression = D.Expression;
-            type mutable = boolean;
-            namespace _ltype {
-                type O = D.Type;
-            }
-            type _ltype = pt.OptionalValue<D.Type>;
-        }
-        type DX = {
-            readonly 'expression': D.Expression;
-            readonly 'mutable': boolean;
-            readonly 'type': pt.OptionalValue<D.Type>;
-        };
-    }
-    type Variables = pt.Dictionary<{
-        readonly 'expression': D.Expression;
-        readonly 'mutable': boolean;
-        readonly 'type': pt.OptionalValue<D.Type>;
-    }>;
-}
-export declare namespace I { }
-export declare namespace A { }