exupery 0.1.17 → 0.1.18

package/dist/generated/interface/schemas/typescript_light/data_types/source.d.ts

@@ -0,0 +1,1101 @@
+import * as _pt from 'exupery-core-types';
+import * as _i_core from "../../../core/resolved";
+export type _T_Block = _i_core._T_List<null, _T_Block_Part>;
+export type _T_Block_Part = _i_core._T_State_Group<null, readonly ['line', string] | readonly ['nested line', _T_Line] | readonly ['nothing', null] | readonly ['sub block', _T_Block]>;
+export type _T_Directory = _i_core._T_Dictionary<null, _i_core._T_State_Group<null, readonly ['directory', _T_Directory] | readonly ['file', _T_Block]>>;
+export type _T_Expression = _i_core._T_State_Group<null, readonly ['array literal', _i_core._T_List<null, _T_Expression>] | readonly [
+    'arrow function',
+    {
+        readonly 'parameters': _i_core._T_List<null, {
+            readonly 'name': string;
+            readonly 'type': _pt.Optional_Value<_T_Type>;
+        }>;
+        readonly 'return type': _pt.Optional_Value<_T_Type>;
+        readonly 'type': _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+    }
+] | readonly [
+    'call',
+    {
+        readonly 'arguments': _i_core._T_List<null, _T_Expression>;
+        readonly 'function selection': _T_Expression;
+    }
+] | readonly ['false', null] | readonly ['null', null] | readonly ['number literal', number] | readonly [
+    'object literal',
+    {
+        readonly 'properties': _i_core._T_Dictionary<null, _T_Expression>;
+    }
+] | readonly ['string literal', _T_String_Literal] | readonly ['true', null]>;
+export type _T_Line = _i_core._T_List<null, _T_Line_Part>;
+export type _T_Line_Part = _i_core._T_State_Group<null, readonly ['indent', _T_Block] | readonly ['nothing', null] | readonly ['snippet', string] | readonly ['sub line', _T_Line]>;
+export type _T_Lines = _i_core._T_List<null, {
+    readonly 'indentation': number;
+    readonly 'text': string;
+}>;
+export type _T_Statements = _i_core._T_List<null, _i_core._T_State_Group<null, readonly [
+    'import',
+    {
+        readonly 'from': string;
+        readonly 'type': _i_core._T_State_Group<null, readonly [
+            'named',
+            {
+                readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+            }
+        ] | readonly ['namespace', string]>;
+    }
+] | readonly [
+    'module declaration',
+    {
+        readonly 'block': _T_Statements;
+        readonly 'export': boolean;
+        readonly 'name': string;
+    }
+] | readonly [
+    'type alias declaration',
+    {
+        readonly 'export': boolean;
+        readonly 'name': string;
+        readonly 'parameters': _i_core._T_List<null, string>;
+        readonly 'type': _T_Type;
+    }
+] | readonly [
+    'variable',
+    {
+        readonly 'const': boolean;
+        readonly 'export': boolean;
+        readonly 'expression': _pt.Optional_Value<_T_Expression>;
+        readonly 'name': string;
+        readonly 'type': _pt.Optional_Value<_T_Type>;
+    }
+]>>;
+export type _T_String_Literal = {
+    readonly 'delimiter': _i_core._T_State_Group<null, readonly ['apostrophe', null] | readonly ['quote', null]>;
+    readonly 'value': string;
+};
+export type _T_Type = _i_core._T_State_Group<null, readonly ['boolean', null] | readonly [
+    'function',
+    {
+        readonly 'parameters': _i_core._T_List<null, {
+            readonly 'name': string;
+            readonly 'type': _pt.Optional_Value<_T_Type>;
+        }>;
+        readonly 'return': _T_Type;
+        readonly 'type parameters': _i_core._T_List<null, string>;
+    }
+] | readonly ['literal type', _T_String_Literal] | readonly ['null', null] | readonly ['number', null] | readonly ['string', null] | readonly [
+    'tuple',
+    {
+        readonly 'elements': _i_core._T_List<null, _T_Type>;
+        readonly 'readonly': boolean;
+    }
+] | readonly [
+    'type literal',
+    {
+        readonly 'properties': _i_core._T_Dictionary<null, {
+            readonly 'readonly': boolean;
+            readonly 'type': _T_Type;
+        }>;
+    }
+] | readonly [
+    'type reference',
+    {
+        readonly 'start': string;
+        readonly 'tail': _i_core._T_List<null, string>;
+        readonly 'type arguments': _i_core._T_List<null, _T_Type>;
+    }
+] | readonly ['union', _i_core._T_List<null, _T_Type>] | readonly ['void', null]>;
+export type Block = _T_Block;
+export type Block_Part = _T_Block_Part;
+export type Directory = _T_Directory;
+export type Expression = _T_Expression;
+export type Line = _T_Line;
+export type Line_Part = _T_Line_Part;
+export type Lines = _T_Lines;
+export type Statements = _T_Statements;
+export type String_Literal = _T_String_Literal;
+export type Type = _T_Type;
+export declare namespace _T_Block {
+    namespace L {
+    }
+    type L = _T_Block_Part;
+}
+export declare namespace _T_Block_Part {
+    namespace SG {
+        type line = string;
+        namespace nested_line {
+        }
+        type nested_line = _T_Line;
+        type nothing = null;
+        namespace sub_block {
+        }
+        type sub_block = _T_Block;
+    }
+    type SG = readonly ['line', string] | readonly ['nested line', _T_Line] | readonly ['nothing', null] | readonly ['sub block', _T_Block];
+}
+export declare namespace _T_Directory {
+    namespace D {
+        namespace SG {
+            namespace directory {
+            }
+            type directory = _T_Directory;
+            namespace file {
+            }
+            type file = _T_Block;
+        }
+        type SG = readonly ['directory', _T_Directory] | readonly ['file', _T_Block];
+    }
+    type D = _i_core._T_State_Group<null, readonly ['directory', _T_Directory] | readonly ['file', _T_Block]>;
+}
+export declare namespace _T_Expression {
+    namespace SG {
+        namespace array_literal {
+            namespace L {
+            }
+            type L = _T_Expression;
+        }
+        type array_literal = _i_core._T_List<null, _T_Expression>;
+        namespace arrow_function {
+            namespace parameters {
+                namespace L {
+                    type name = string;
+                    namespace _type {
+                        namespace O {
+                        }
+                        type O = _T_Type;
+                    }
+                    type _type = _pt.Optional_Value<_T_Type>;
+                }
+                type L = {
+                    readonly 'name': string;
+                    readonly 'type': _pt.Optional_Value<_T_Type>;
+                };
+            }
+            type parameters = _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            namespace return_type {
+                namespace O {
+                }
+                type O = _T_Type;
+            }
+            type return_type = _pt.Optional_Value<_T_Type>;
+            namespace _type {
+                namespace SG {
+                    namespace block {
+                    }
+                    type block = _T_Statements;
+                    namespace expression {
+                    }
+                    type expression = _T_Expression;
+                }
+                type SG = readonly ['block', _T_Statements] | readonly ['expression', _T_Expression];
+            }
+            type _type = _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+        }
+        type arrow_function = {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return type': _pt.Optional_Value<_T_Type>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+        };
+        namespace call {
+            namespace _arguments {
+                namespace L {
+                }
+                type L = _T_Expression;
+            }
+            type _arguments = _i_core._T_List<null, _T_Expression>;
+            namespace function_selection {
+            }
+            type function_selection = _T_Expression;
+        }
+        type call = {
+            readonly 'arguments': _i_core._T_List<null, _T_Expression>;
+            readonly 'function selection': _T_Expression;
+        };
+        type _false = null;
+        type _null = null;
+        type number_literal = number;
+        namespace object_literal {
+            namespace properties {
+                namespace D {
+                }
+                type D = _T_Expression;
+            }
+            type properties = _i_core._T_Dictionary<null, _T_Expression>;
+        }
+        type object_literal = {
+            readonly 'properties': _i_core._T_Dictionary<null, _T_Expression>;
+        };
+        namespace string_literal {
+        }
+        type string_literal = _T_String_Literal;
+        type _true = null;
+    }
+    type SG = readonly ['array literal', _i_core._T_List<null, _T_Expression>] | readonly [
+        'arrow function',
+        {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return type': _pt.Optional_Value<_T_Type>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+        }
+    ] | readonly [
+        'call',
+        {
+            readonly 'arguments': _i_core._T_List<null, _T_Expression>;
+            readonly 'function selection': _T_Expression;
+        }
+    ] | readonly ['false', null] | readonly ['null', null] | readonly ['number literal', number] | readonly [
+        'object literal',
+        {
+            readonly 'properties': _i_core._T_Dictionary<null, _T_Expression>;
+        }
+    ] | readonly ['string literal', _T_String_Literal] | readonly ['true', null];
+}
+export declare namespace _T_Line {
+    namespace L {
+    }
+    type L = _T_Line_Part;
+}
+export declare namespace _T_Line_Part {
+    namespace SG {
+        namespace indent {
+        }
+        type indent = _T_Block;
+        type nothing = null;
+        type snippet = string;
+        namespace sub_line {
+        }
+        type sub_line = _T_Line;
+    }
+    type SG = readonly ['indent', _T_Block] | readonly ['nothing', null] | readonly ['snippet', string] | readonly ['sub line', _T_Line];
+}
+export declare namespace _T_Lines {
+    namespace L {
+        type indentation = number;
+        type text = string;
+    }
+    type L = {
+        readonly 'indentation': number;
+        readonly 'text': string;
+    };
+}
+export declare namespace _T_Statements {
+    namespace L {
+        namespace SG {
+            namespace _import {
+                type _from = string;
+                namespace _type {
+                    namespace SG {
+                        namespace named {
+                            namespace specifiers {
+                                type D = string;
+                            }
+                            type specifiers = _i_core._T_Dictionary<null, string>;
+                        }
+                        type named = {
+                            readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                        };
+                        type namespace = string;
+                    }
+                    type SG = readonly [
+                        'named',
+                        {
+                            readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                        }
+                    ] | readonly ['namespace', string];
+                }
+                type _type = _i_core._T_State_Group<null, readonly [
+                    'named',
+                    {
+                        readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                    }
+                ] | readonly ['namespace', string]>;
+            }
+            type _import = {
+                readonly 'from': string;
+                readonly 'type': _i_core._T_State_Group<null, readonly [
+                    'named',
+                    {
+                        readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                    }
+                ] | readonly ['namespace', string]>;
+            };
+            namespace module_declaration {
+                namespace block {
+                }
+                type block = _T_Statements;
+                type _export = boolean;
+                type name = string;
+            }
+            type module_declaration = {
+                readonly 'block': _T_Statements;
+                readonly 'export': boolean;
+                readonly 'name': string;
+            };
+            namespace type_alias_declaration {
+                type _export = boolean;
+                type name = string;
+                namespace parameters {
+                    type L = string;
+                }
+                type parameters = _i_core._T_List<null, string>;
+                namespace _type {
+                }
+                type _type = _T_Type;
+            }
+            type type_alias_declaration = {
+                readonly 'export': boolean;
+                readonly 'name': string;
+                readonly 'parameters': _i_core._T_List<null, string>;
+                readonly 'type': _T_Type;
+            };
+            namespace variable {
+                type _const = boolean;
+                type _export = boolean;
+                namespace expression {
+                    namespace O {
+                    }
+                    type O = _T_Expression;
+                }
+                type expression = _pt.Optional_Value<_T_Expression>;
+                type name = string;
+                namespace _type {
+                    namespace O {
+                    }
+                    type O = _T_Type;
+                }
+                type _type = _pt.Optional_Value<_T_Type>;
+            }
+            type variable = {
+                readonly 'const': boolean;
+                readonly 'export': boolean;
+                readonly 'expression': _pt.Optional_Value<_T_Expression>;
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            };
+        }
+        type SG = readonly [
+            'import',
+            {
+                readonly 'from': string;
+                readonly 'type': _i_core._T_State_Group<null, readonly [
+                    'named',
+                    {
+                        readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                    }
+                ] | readonly ['namespace', string]>;
+            }
+        ] | readonly [
+            'module declaration',
+            {
+                readonly 'block': _T_Statements;
+                readonly 'export': boolean;
+                readonly 'name': string;
+            }
+        ] | readonly [
+            'type alias declaration',
+            {
+                readonly 'export': boolean;
+                readonly 'name': string;
+                readonly 'parameters': _i_core._T_List<null, string>;
+                readonly 'type': _T_Type;
+            }
+        ] | readonly [
+            'variable',
+            {
+                readonly 'const': boolean;
+                readonly 'export': boolean;
+                readonly 'expression': _pt.Optional_Value<_T_Expression>;
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }
+        ];
+    }
+    type L = _i_core._T_State_Group<null, readonly [
+        'import',
+        {
+            readonly 'from': string;
+            readonly 'type': _i_core._T_State_Group<null, readonly [
+                'named',
+                {
+                    readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                }
+            ] | readonly ['namespace', string]>;
+        }
+    ] | readonly [
+        'module declaration',
+        {
+            readonly 'block': _T_Statements;
+            readonly 'export': boolean;
+            readonly 'name': string;
+        }
+    ] | readonly [
+        'type alias declaration',
+        {
+            readonly 'export': boolean;
+            readonly 'name': string;
+            readonly 'parameters': _i_core._T_List<null, string>;
+            readonly 'type': _T_Type;
+        }
+    ] | readonly [
+        'variable',
+        {
+            readonly 'const': boolean;
+            readonly 'export': boolean;
+            readonly 'expression': _pt.Optional_Value<_T_Expression>;
+            readonly 'name': string;
+            readonly 'type': _pt.Optional_Value<_T_Type>;
+        }
+    ]>;
+}
+export declare namespace _T_String_Literal {
+    namespace delimiter {
+        namespace SG {
+            type apostrophe = null;
+            type quote = null;
+        }
+        type SG = readonly ['apostrophe', null] | readonly ['quote', null];
+    }
+    type delimiter = _i_core._T_State_Group<null, readonly ['apostrophe', null] | readonly ['quote', null]>;
+    type value = string;
+}
+export declare namespace _T_Type {
+    namespace SG {
+        type _boolean = null;
+        namespace _function {
+            namespace parameters {
+                namespace L {
+                    type name = string;
+                    namespace _type {
+                        namespace O {
+                        }
+                        type O = _T_Type;
+                    }
+                    type _type = _pt.Optional_Value<_T_Type>;
+                }
+                type L = {
+                    readonly 'name': string;
+                    readonly 'type': _pt.Optional_Value<_T_Type>;
+                };
+            }
+            type parameters = _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            namespace _return {
+            }
+            type _return = _T_Type;
+            namespace type_parameters {
+                type L = string;
+            }
+            type type_parameters = _i_core._T_List<null, string>;
+        }
+        type _function = {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return': _T_Type;
+            readonly 'type parameters': _i_core._T_List<null, string>;
+        };
+        namespace literal_type {
+        }
+        type literal_type = _T_String_Literal;
+        type _null = null;
+        type _number = null;
+        type _string = null;
+        namespace tuple {
+            namespace elements {
+                namespace L {
+                }
+                type L = _T_Type;
+            }
+            type elements = _i_core._T_List<null, _T_Type>;
+            type readonly = boolean;
+        }
+        type tuple = {
+            readonly 'elements': _i_core._T_List<null, _T_Type>;
+            readonly 'readonly': boolean;
+        };
+        namespace type_literal {
+            namespace properties {
+                namespace D {
+                    type readonly = boolean;
+                    namespace _type {
+                    }
+                    type _type = _T_Type;
+                }
+                type D = {
+                    readonly 'readonly': boolean;
+                    readonly 'type': _T_Type;
+                };
+            }
+            type properties = _i_core._T_Dictionary<null, {
+                readonly 'readonly': boolean;
+                readonly 'type': _T_Type;
+            }>;
+        }
+        type type_literal = {
+            readonly 'properties': _i_core._T_Dictionary<null, {
+                readonly 'readonly': boolean;
+                readonly 'type': _T_Type;
+            }>;
+        };
+        namespace type_reference {
+            type start = string;
+            namespace tail {
+                type L = string;
+            }
+            type tail = _i_core._T_List<null, string>;
+            namespace type_arguments {
+                namespace L {
+                }
+                type L = _T_Type;
+            }
+            type type_arguments = _i_core._T_List<null, _T_Type>;
+        }
+        type type_reference = {
+            readonly 'start': string;
+            readonly 'tail': _i_core._T_List<null, string>;
+            readonly 'type arguments': _i_core._T_List<null, _T_Type>;
+        };
+        namespace union {
+            namespace L {
+            }
+            type L = _T_Type;
+        }
+        type union = _i_core._T_List<null, _T_Type>;
+        type _void = null;
+    }
+    type SG = readonly ['boolean', null] | readonly [
+        'function',
+        {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return': _T_Type;
+            readonly 'type parameters': _i_core._T_List<null, string>;
+        }
+    ] | readonly ['literal type', _T_String_Literal] | readonly ['null', null] | readonly ['number', null] | readonly ['string', null] | readonly [
+        'tuple',
+        {
+            readonly 'elements': _i_core._T_List<null, _T_Type>;
+            readonly 'readonly': boolean;
+        }
+    ] | readonly [
+        'type literal',
+        {
+            readonly 'properties': _i_core._T_Dictionary<null, {
+                readonly 'readonly': boolean;
+                readonly 'type': _T_Type;
+            }>;
+        }
+    ] | readonly [
+        'type reference',
+        {
+            readonly 'start': string;
+            readonly 'tail': _i_core._T_List<null, string>;
+            readonly 'type arguments': _i_core._T_List<null, _T_Type>;
+        }
+    ] | readonly ['union', _i_core._T_List<null, _T_Type>] | readonly ['void', null];
+}
+export declare namespace Block {
+    namespace L {
+    }
+    type L = _T_Block_Part;
+}
+export declare namespace Block_Part {
+    namespace SG {
+        type line = string;
+        namespace nested_line {
+        }
+        type nested_line = _T_Line;
+        type nothing = null;
+        namespace sub_block {
+        }
+        type sub_block = _T_Block;
+    }
+    type SG = readonly ['line', string] | readonly ['nested line', _T_Line] | readonly ['nothing', null] | readonly ['sub block', _T_Block];
+}
+export declare namespace Directory {
+    namespace D {
+        namespace SG {
+            namespace directory {
+            }
+            type directory = _T_Directory;
+            namespace file {
+            }
+            type file = _T_Block;
+        }
+        type SG = readonly ['directory', _T_Directory] | readonly ['file', _T_Block];
+    }
+    type D = _i_core._T_State_Group<null, readonly ['directory', _T_Directory] | readonly ['file', _T_Block]>;
+}
+export declare namespace Expression {
+    namespace SG {
+        namespace array_literal {
+            namespace L {
+            }
+            type L = _T_Expression;
+        }
+        type array_literal = _i_core._T_List<null, _T_Expression>;
+        namespace arrow_function {
+            namespace parameters {
+                namespace L {
+                    type name = string;
+                    namespace _type {
+                        namespace O {
+                        }
+                        type O = _T_Type;
+                    }
+                    type _type = _pt.Optional_Value<_T_Type>;
+                }
+                type L = {
+                    readonly 'name': string;
+                    readonly 'type': _pt.Optional_Value<_T_Type>;
+                };
+            }
+            type parameters = _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            namespace return_type {
+                namespace O {
+                }
+                type O = _T_Type;
+            }
+            type return_type = _pt.Optional_Value<_T_Type>;
+            namespace _type {
+                namespace SG {
+                    namespace block {
+                    }
+                    type block = _T_Statements;
+                    namespace expression {
+                    }
+                    type expression = _T_Expression;
+                }
+                type SG = readonly ['block', _T_Statements] | readonly ['expression', _T_Expression];
+            }
+            type _type = _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+        }
+        type arrow_function = {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return type': _pt.Optional_Value<_T_Type>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+        };
+        namespace call {
+            namespace _arguments {
+                namespace L {
+                }
+                type L = _T_Expression;
+            }
+            type _arguments = _i_core._T_List<null, _T_Expression>;
+            namespace function_selection {
+            }
+            type function_selection = _T_Expression;
+        }
+        type call = {
+            readonly 'arguments': _i_core._T_List<null, _T_Expression>;
+            readonly 'function selection': _T_Expression;
+        };
+        type _false = null;
+        type _null = null;
+        type number_literal = number;
+        namespace object_literal {
+            namespace properties {
+                namespace D {
+                }
+                type D = _T_Expression;
+            }
+            type properties = _i_core._T_Dictionary<null, _T_Expression>;
+        }
+        type object_literal = {
+            readonly 'properties': _i_core._T_Dictionary<null, _T_Expression>;
+        };
+        namespace string_literal {
+        }
+        type string_literal = _T_String_Literal;
+        type _true = null;
+    }
+    type SG = readonly ['array literal', _i_core._T_List<null, _T_Expression>] | readonly [
+        'arrow function',
+        {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return type': _pt.Optional_Value<_T_Type>;
+            readonly 'type': _i_core._T_State_Group<null, readonly ['block', _T_Statements] | readonly ['expression', _T_Expression]>;
+        }
+    ] | readonly [
+        'call',
+        {
+            readonly 'arguments': _i_core._T_List<null, _T_Expression>;
+            readonly 'function selection': _T_Expression;
+        }
+    ] | readonly ['false', null] | readonly ['null', null] | readonly ['number literal', number] | readonly [
+        'object literal',
+        {
+            readonly 'properties': _i_core._T_Dictionary<null, _T_Expression>;
+        }
+    ] | readonly ['string literal', _T_String_Literal] | readonly ['true', null];
+}
+export declare namespace Line {
+    namespace L {
+    }
+    type L = _T_Line_Part;
+}
+export declare namespace Line_Part {
+    namespace SG {
+        namespace indent {
+        }
+        type indent = _T_Block;
+        type nothing = null;
+        type snippet = string;
+        namespace sub_line {
+        }
+        type sub_line = _T_Line;
+    }
+    type SG = readonly ['indent', _T_Block] | readonly ['nothing', null] | readonly ['snippet', string] | readonly ['sub line', _T_Line];
+}
+export declare namespace Lines {
+    namespace L {
+        type indentation = number;
+        type text = string;
+    }
+    type L = {
+        readonly 'indentation': number;
+        readonly 'text': string;
+    };
+}
+export declare namespace Statements {
+    namespace L {
+        namespace SG {
+            namespace _import {
+                type _from = string;
+                namespace _type {
+                    namespace SG {
+                        namespace named {
+                            namespace specifiers {
+                                type D = string;
+                            }
+                            type specifiers = _i_core._T_Dictionary<null, string>;
+                        }
+                        type named = {
+                            readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                        };
+                        type namespace = string;
+                    }
+                    type SG = readonly [
+                        'named',
+                        {
+                            readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                        }
+                    ] | readonly ['namespace', string];
+                }
+                type _type = _i_core._T_State_Group<null, readonly [
+                    'named',
+                    {
+                        readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                    }
+                ] | readonly ['namespace', string]>;
+            }
+            type _import = {
+                readonly 'from': string;
+                readonly 'type': _i_core._T_State_Group<null, readonly [
+                    'named',
+                    {
+                        readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                    }
+                ] | readonly ['namespace', string]>;
+            };
+            namespace module_declaration {
+                namespace block {
+                }
+                type block = _T_Statements;
+                type _export = boolean;
+                type name = string;
+            }
+            type module_declaration = {
+                readonly 'block': _T_Statements;
+                readonly 'export': boolean;
+                readonly 'name': string;
+            };
+            namespace type_alias_declaration {
+                type _export = boolean;
+                type name = string;
+                namespace parameters {
+                    type L = string;
+                }
+                type parameters = _i_core._T_List<null, string>;
+                namespace _type {
+                }
+                type _type = _T_Type;
+            }
+            type type_alias_declaration = {
+                readonly 'export': boolean;
+                readonly 'name': string;
+                readonly 'parameters': _i_core._T_List<null, string>;
+                readonly 'type': _T_Type;
+            };
+            namespace variable {
+                type _const = boolean;
+                type _export = boolean;
+                namespace expression {
+                    namespace O {
+                    }
+                    type O = _T_Expression;
+                }
+                type expression = _pt.Optional_Value<_T_Expression>;
+                type name = string;
+                namespace _type {
+                    namespace O {
+                    }
+                    type O = _T_Type;
+                }
+                type _type = _pt.Optional_Value<_T_Type>;
+            }
+            type variable = {
+                readonly 'const': boolean;
+                readonly 'export': boolean;
+                readonly 'expression': _pt.Optional_Value<_T_Expression>;
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            };
+        }
+        type SG = readonly [
+            'import',
+            {
+                readonly 'from': string;
+                readonly 'type': _i_core._T_State_Group<null, readonly [
+                    'named',
+                    {
+                        readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                    }
+                ] | readonly ['namespace', string]>;
+            }
+        ] | readonly [
+            'module declaration',
+            {
+                readonly 'block': _T_Statements;
+                readonly 'export': boolean;
+                readonly 'name': string;
+            }
+        ] | readonly [
+            'type alias declaration',
+            {
+                readonly 'export': boolean;
+                readonly 'name': string;
+                readonly 'parameters': _i_core._T_List<null, string>;
+                readonly 'type': _T_Type;
+            }
+        ] | readonly [
+            'variable',
+            {
+                readonly 'const': boolean;
+                readonly 'export': boolean;
+                readonly 'expression': _pt.Optional_Value<_T_Expression>;
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }
+        ];
+    }
+    type L = _i_core._T_State_Group<null, readonly [
+        'import',
+        {
+            readonly 'from': string;
+            readonly 'type': _i_core._T_State_Group<null, readonly [
+                'named',
+                {
+                    readonly 'specifiers': _i_core._T_Dictionary<null, string>;
+                }
+            ] | readonly ['namespace', string]>;
+        }
+    ] | readonly [
+        'module declaration',
+        {
+            readonly 'block': _T_Statements;
+            readonly 'export': boolean;
+            readonly 'name': string;
+        }
+    ] | readonly [
+        'type alias declaration',
+        {
+            readonly 'export': boolean;
+            readonly 'name': string;
+            readonly 'parameters': _i_core._T_List<null, string>;
+            readonly 'type': _T_Type;
+        }
+    ] | readonly [
+        'variable',
+        {
+            readonly 'const': boolean;
+            readonly 'export': boolean;
+            readonly 'expression': _pt.Optional_Value<_T_Expression>;
+            readonly 'name': string;
+            readonly 'type': _pt.Optional_Value<_T_Type>;
+        }
+    ]>;
+}
+export declare namespace String_Literal {
+    namespace delimiter {
+        namespace SG {
+            type apostrophe = null;
+            type quote = null;
+        }
+        type SG = readonly ['apostrophe', null] | readonly ['quote', null];
+    }
+    type delimiter = _i_core._T_State_Group<null, readonly ['apostrophe', null] | readonly ['quote', null]>;
+    type value = string;
+}
+export declare namespace Type {
+    namespace SG {
+        type _boolean = null;
+        namespace _function {
+            namespace parameters {
+                namespace L {
+                    type name = string;
+                    namespace _type {
+                        namespace O {
+                        }
+                        type O = _T_Type;
+                    }
+                    type _type = _pt.Optional_Value<_T_Type>;
+                }
+                type L = {
+                    readonly 'name': string;
+                    readonly 'type': _pt.Optional_Value<_T_Type>;
+                };
+            }
+            type parameters = _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            namespace _return {
+            }
+            type _return = _T_Type;
+            namespace type_parameters {
+                type L = string;
+            }
+            type type_parameters = _i_core._T_List<null, string>;
+        }
+        type _function = {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return': _T_Type;
+            readonly 'type parameters': _i_core._T_List<null, string>;
+        };
+        namespace literal_type {
+        }
+        type literal_type = _T_String_Literal;
+        type _null = null;
+        type _number = null;
+        type _string = null;
+        namespace tuple {
+            namespace elements {
+                namespace L {
+                }
+                type L = _T_Type;
+            }
+            type elements = _i_core._T_List<null, _T_Type>;
+            type readonly = boolean;
+        }
+        type tuple = {
+            readonly 'elements': _i_core._T_List<null, _T_Type>;
+            readonly 'readonly': boolean;
+        };
+        namespace type_literal {
+            namespace properties {
+                namespace D {
+                    type readonly = boolean;
+                    namespace _type {
+                    }
+                    type _type = _T_Type;
+                }
+                type D = {
+                    readonly 'readonly': boolean;
+                    readonly 'type': _T_Type;
+                };
+            }
+            type properties = _i_core._T_Dictionary<null, {
+                readonly 'readonly': boolean;
+                readonly 'type': _T_Type;
+            }>;
+        }
+        type type_literal = {
+            readonly 'properties': _i_core._T_Dictionary<null, {
+                readonly 'readonly': boolean;
+                readonly 'type': _T_Type;
+            }>;
+        };
+        namespace type_reference {
+            type start = string;
+            namespace tail {
+                type L = string;
+            }
+            type tail = _i_core._T_List<null, string>;
+            namespace type_arguments {
+                namespace L {
+                }
+                type L = _T_Type;
+            }
+            type type_arguments = _i_core._T_List<null, _T_Type>;
+        }
+        type type_reference = {
+            readonly 'start': string;
+            readonly 'tail': _i_core._T_List<null, string>;
+            readonly 'type arguments': _i_core._T_List<null, _T_Type>;
+        };
+        namespace union {
+            namespace L {
+            }
+            type L = _T_Type;
+        }
+        type union = _i_core._T_List<null, _T_Type>;
+        type _void = null;
+    }
+    type SG = readonly ['boolean', null] | readonly [
+        'function',
+        {
+            readonly 'parameters': _i_core._T_List<null, {
+                readonly 'name': string;
+                readonly 'type': _pt.Optional_Value<_T_Type>;
+            }>;
+            readonly 'return': _T_Type;
+            readonly 'type parameters': _i_core._T_List<null, string>;
+        }
+    ] | readonly ['literal type', _T_String_Literal] | readonly ['null', null] | readonly ['number', null] | readonly ['string', null] | readonly [
+        'tuple',
+        {
+            readonly 'elements': _i_core._T_List<null, _T_Type>;
+            readonly 'readonly': boolean;
+        }
+    ] | readonly [
+        'type literal',
+        {
+            readonly 'properties': _i_core._T_Dictionary<null, {
+                readonly 'readonly': boolean;
+                readonly 'type': _T_Type;
+            }>;
+        }
+    ] | readonly [
+        'type reference',
+        {
+            readonly 'start': string;
+            readonly 'tail': _i_core._T_List<null, string>;
+            readonly 'type arguments': _i_core._T_List<null, _T_Type>;
+        }
+    ] | readonly ['union', _i_core._T_List<null, _T_Type>] | readonly ['void', null];
+}