pareto 0.51.1 → 0.53.0

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

@@ -0,0 +1,1267 @@
+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 array_$_$literal {
+                        namespace N {
+                            namespace A {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    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 dictionary_$_$literal {
+                        namespace N {
+                            namespace DX {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace _$lfalse {
+                        namespace N { }
+                        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_$_$literal {
+                        namespace N {
+                            namespace DX {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace implement_$_$me {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace not_$_$set {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace null_$_$literal {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace number_$_$literal {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace panic {
+                        namespace N { }
+                        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 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 _$lset {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace state_$_$literal {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace data {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                    namespace state {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace string_$_$literal {
+                        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 ternary_$_$condition {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace condition {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                    namespace false_$_$expression {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                    namespace true_$_$expression {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace _$ltrue {
+                        namespace N { }
+                        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 array__literal {
+            type A = D.Expression;
+        }
+        type array__literal = pt.Array<D.Expression>;
+        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;
+        };
+        namespace dictionary__literal {
+            type DX = D.Expression;
+        }
+        type dictionary__literal = pt.Dictionary<D.Expression>;
+        type _lfalse = null;
+        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__literal {
+            type DX = D.Expression;
+        }
+        type group__literal = pt.Dictionary<D.Expression>;
+        type implement__me = string;
+        type not__set = null;
+        type null__literal = null;
+        type number__literal = number;
+        type panic = string;
+        namespace selection {
+            namespace start {
+                type context = null;
+                type parameter = string;
+                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] | [
+                '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] | [
+                '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 _lset = D.Expression;
+        namespace state__literal {
+            type data = D.Expression;
+            type state = string;
+        }
+        type state__literal = {
+            readonly 'data': D.Expression;
+            readonly 'state': string;
+        };
+        type string__literal = string;
+        namespace _lswitch {
+            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 select = D.Expression;
+        }
+        type _lswitch = {
+            readonly 'cases': pt.Dictionary<D.Expression>;
+            readonly 'default': pt.OptionalValue<D.Expression>;
+            readonly 'select': D.Expression;
+        };
+        namespace ternary__condition {
+            type condition = D.Expression;
+            type false__expression = D.Expression;
+            type true__expression = D.Expression;
+        }
+        type ternary__condition = {
+            readonly 'condition': D.Expression;
+            readonly 'false expression': D.Expression;
+            readonly 'true expression': D.Expression;
+        };
+        type _ltrue = null;
+    }
+    type Expression = ['array literal', pt.Array<D.Expression>] | ['block', D.Statement__Block] | [
+        'change context',
+        {
+            readonly 'new context selection': D.Expression;
+            readonly 'sub expression': D.Expression;
+        }
+    ] | ['dictionary literal', pt.Dictionary<D.Expression>] | ['false', null] | [
+        'function',
+        {
+            readonly 'block': D.Statement__Block;
+            readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+        }
+    ] | ['group literal', pt.Dictionary<D.Expression>] | ['implement me', string] | ['not set', null] | ['null literal', null] | ['number literal', number] | ['panic', string] | [
+        'selection',
+        {
+            readonly 'start': ['context', null] | ['parameter', string] | [
+                '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]>;
+        }
+    ] | ['set', D.Expression] | [
+        'state literal',
+        {
+            readonly 'data': D.Expression;
+            readonly 'state': string;
+        }
+    ] | ['string literal', string] | [
+        'switch',
+        {
+            readonly 'cases': pt.Dictionary<D.Expression>;
+            readonly 'default': pt.OptionalValue<D.Expression>;
+            readonly 'select': D.Expression;
+        }
+    ] | [
+        'ternary condition',
+        {
+            readonly 'condition': D.Expression;
+            readonly 'false expression': D.Expression;
+            readonly 'true expression': D.Expression;
+        }
+    ] | ['true', null];
+    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 { }