astn 0.110.19 → 0.110.21

package/dist/generated/interface/core/astn_target.d.ts

@@ -0,0 +1,186 @@
+import * as _pt from 'exupery-core-types';
+export type _T_Document = _T_Value;
+export type _T_Value = readonly ['concise group', _pt.Array<_T_Value>] | readonly ['dictionary', _pt.Dictionary<_T_Value>] | readonly ['list', _pt.Array<_T_Value>] | readonly ['nothing', null] | readonly [
+    'optional',
+    readonly ['not set', null] | readonly ['set', _T_Value]
+] | readonly [
+    'state',
+    {
+        readonly 'state': string;
+        readonly 'value': _T_Value;
+    }
+] | readonly [
+    'text',
+    {
+        readonly 'delimiter': readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+        readonly 'value': string;
+    }
+] | readonly ['verbose group', _pt.Dictionary<_T_Value>];
+export type Document = _T_Document;
+export type Value = _T_Value;
+export declare namespace _T_Document {
+}
+export declare namespace _T_Value {
+    namespace SG {
+        namespace concise_group {
+            namespace L {
+            }
+            type L = _T_Value;
+        }
+        type concise_group = _pt.Array<_T_Value>;
+        namespace dictionary {
+            namespace D {
+            }
+            type D = _T_Value;
+        }
+        type dictionary = _pt.Dictionary<_T_Value>;
+        namespace list {
+            namespace L {
+            }
+            type L = _T_Value;
+        }
+        type list = _pt.Array<_T_Value>;
+        type nothing = null;
+        namespace optional {
+            namespace SG {
+                type not_set = null;
+                namespace _set {
+                }
+                type _set = _T_Value;
+            }
+            type SG = readonly ['not set', null] | readonly ['set', _T_Value];
+        }
+        type optional = readonly ['not set', null] | readonly ['set', _T_Value];
+        namespace state {
+            type state = string;
+            namespace value {
+            }
+            type value = _T_Value;
+        }
+        type state = {
+            readonly 'state': string;
+            readonly 'value': _T_Value;
+        };
+        namespace text {
+            namespace delimiter {
+                namespace SG {
+                    type backtick = null;
+                    type none = null;
+                    type quote = null;
+                }
+                type SG = readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            }
+            type delimiter = readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            type value = string;
+        }
+        type text = {
+            readonly 'delimiter': readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            readonly 'value': string;
+        };
+        namespace verbose_group {
+            namespace D {
+            }
+            type D = _T_Value;
+        }
+        type verbose_group = _pt.Dictionary<_T_Value>;
+    }
+    type SG = readonly ['concise group', _pt.Array<_T_Value>] | readonly ['dictionary', _pt.Dictionary<_T_Value>] | readonly ['list', _pt.Array<_T_Value>] | readonly ['nothing', null] | readonly [
+        'optional',
+        readonly ['not set', null] | readonly ['set', _T_Value]
+    ] | readonly [
+        'state',
+        {
+            readonly 'state': string;
+            readonly 'value': _T_Value;
+        }
+    ] | readonly [
+        'text',
+        {
+            readonly 'delimiter': readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            readonly 'value': string;
+        }
+    ] | readonly ['verbose group', _pt.Dictionary<_T_Value>];
+}
+export declare namespace Document {
+}
+export declare namespace Value {
+    namespace SG {
+        namespace concise_group {
+            namespace L {
+            }
+            type L = _T_Value;
+        }
+        type concise_group = _pt.Array<_T_Value>;
+        namespace dictionary {
+            namespace D {
+            }
+            type D = _T_Value;
+        }
+        type dictionary = _pt.Dictionary<_T_Value>;
+        namespace list {
+            namespace L {
+            }
+            type L = _T_Value;
+        }
+        type list = _pt.Array<_T_Value>;
+        type nothing = null;
+        namespace optional {
+            namespace SG {
+                type not_set = null;
+                namespace _set {
+                }
+                type _set = _T_Value;
+            }
+            type SG = readonly ['not set', null] | readonly ['set', _T_Value];
+        }
+        type optional = readonly ['not set', null] | readonly ['set', _T_Value];
+        namespace state {
+            type state = string;
+            namespace value {
+            }
+            type value = _T_Value;
+        }
+        type state = {
+            readonly 'state': string;
+            readonly 'value': _T_Value;
+        };
+        namespace text {
+            namespace delimiter {
+                namespace SG {
+                    type backtick = null;
+                    type none = null;
+                    type quote = null;
+                }
+                type SG = readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            }
+            type delimiter = readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            type value = string;
+        }
+        type text = {
+            readonly 'delimiter': readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            readonly 'value': string;
+        };
+        namespace verbose_group {
+            namespace D {
+            }
+            type D = _T_Value;
+        }
+        type verbose_group = _pt.Dictionary<_T_Value>;
+    }
+    type SG = readonly ['concise group', _pt.Array<_T_Value>] | readonly ['dictionary', _pt.Dictionary<_T_Value>] | readonly ['list', _pt.Array<_T_Value>] | readonly ['nothing', null] | readonly [
+        'optional',
+        readonly ['not set', null] | readonly ['set', _T_Value]
+    ] | readonly [
+        'state',
+        {
+            readonly 'state': string;
+            readonly 'value': _T_Value;
+        }
+    ] | readonly [
+        'text',
+        {
+            readonly 'delimiter': readonly ['backtick', null] | readonly ['none', null] | readonly ['quote', null];
+            readonly 'value': string;
+        }
+    ] | readonly ['verbose group', _pt.Dictionary<_T_Value>];
+}

package/dist/generated/interface/core/astn_target.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN0bl90YXJnZXQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2ludGVyZmFjZS9jb3JlL2FzdG5fdGFyZ2V0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/generated/interface/core/resolve.d.ts

@@ -0,0 +1,11 @@
+import * as pt from 'exupery-core-types';
+export type Location_to_String<Source> = ($: Source) => string;
+export type _T_Location_2_String<Source> = Location_to_String<Source>;
+export type Non_Circular_Result<T> = ['error', ['circular', pt.Array<string>]] | ['resolved', T];
+export type Acyclic_Lookup<T> = pt.Optional_Value<pt.Lookup<Non_Circular_Result<T>>>;
+export type _T_Acyclic_Lookup<T> = Acyclic_Lookup<T>;
+export type Possibly_Circular_Result<T> = pt.Computed_Value<T>;
+export type Cyclic_Lookup<T> = pt.Optional_Value<pt.Lookup<Possibly_Circular_Result<T>>>;
+export type _T_Cyclic_Lookup<T> = Cyclic_Lookup<T>;
+export type Lookup_Stack<T> = pt.Array<Acyclic_Lookup<T>>;
+export type _T_Lookup_Stack<T> = Lookup_Stack<T>;

package/dist/generated/interface/core/resolve.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzb2x2ZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvaW50ZXJmYWNlL2NvcmUvcmVzb2x2ZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/generated/interface/core/unconstrained.d.ts

@@ -0,0 +1,19 @@
+import * as _pt from 'exupery-core-types';
+export type _T_Dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
+export type _T_List<G_Source, T_L> = _pt.Array<T_L>;
+export type _T_State_Group<G_Source, T_SG> = T_SG;
+export type Dictionary<G_Source, T_D> = _T_Dictionary<G_Source, T_D>;
+export type List<G_Source, T_L> = _T_List<G_Source, T_L>;
+export type State_Group<G_Source, T_SG> = _T_State_Group<G_Source, T_SG>;
+export declare namespace _T_Dictionary {
+    type D<G_Source, T_D> = T_D;
+}
+export declare namespace _T_List {
+    type L<G_Source, T_L> = T_L;
+}
+export declare namespace Dictionary {
+    type D<G_Source, T_D> = T_D;
+}
+export declare namespace List {
+    type L<G_Source, T_L> = T_L;
+}

package/dist/generated/interface/core/unconstrained.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidW5jb25zdHJhaW5lZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9nZW5lcmF0ZWQvaW50ZXJmYWNlL2NvcmUvdW5jb25zdHJhaW5lZC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=

package/dist/generated/interface/core/unresolved.d.ts

@@ -1,12 +1,43 @@
 import * as _pt from 'exupery-core-types';
 export type _T_Derived_Reference<G_Source, T_Type> = null;
-export type _T_Dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
-export type _T_List<G_Source, T_L> = _pt.Array<T_L>;
-export type _T_Ordered_Dictionary<G_Source, T_D> = _pt.Dictionary<T_D>;
-export type _T_Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry> = string;
-export type _T_Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> = string;
-export type _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = string;
-export type _T_State_Group<G_Source, T_SG> = T_SG;
+export type _T_Dictionary<G_Source, T_D> = {
+    readonly 'dictionary': _pt.Dictionary<{
+        readonly 'entry': T_D;
+        readonly 'location': G_Source;
+    }>;
+    readonly 'location': G_Source;
+};
+export type _T_List<G_Source, T_L> = {
+    readonly 'list': _pt.Array<{
+        readonly 'element': T_L;
+        readonly 'location': G_Source;
+    }>;
+    readonly 'location': G_Source;
+};
+export type _T_Ordered_Dictionary<G_Source, T_D> = {
+    readonly 'dictionary': _pt.Dictionary<{
+        readonly 'entry': T_D;
+        readonly 'location': G_Source;
+    }>;
+    readonly 'location': G_Source;
+};
+export type _T_Reference_To_Circular_Dependent_Sibling<G_Source, T_Dictionary_Entry> = {
+    readonly 'key': string;
+    readonly 'location': G_Source;
+};
+export type _T_Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> = {
+    readonly 'key': string;
+    readonly 'location': G_Source;
+};
+export type _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = {
+    readonly 'key': string;
+    readonly 'location': G_Source;
+    readonly 'up steps': number;
+};
+export type _T_State_Group<G_Source, T_SG> = {
+    readonly 'location': G_Source;
+    readonly 'state group': T_SG;
+};
 export type Derived_Reference<G_Source, T_Type> = _T_Derived_Reference<G_Source, T_Type>;
 export type Dictionary<G_Source, T_D> = _T_Dictionary<G_Source, T_D>;
 export type List<G_Source, T_L> = _T_List<G_Source, T_L>;
@@ -16,20 +47,138 @@ export type Reference_To_Normal_Dictionary_Entry<G_Source, T_Dictionary_Entry> =
 export type Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry> = _T_Reference_To_Stacked_Dictionary_Entry<G_Source, T_Dictionary_Entry>;
 export type State_Group<G_Source, T_SG> = _T_State_Group<G_Source, T_SG>;
 export declare namespace _T_Dictionary {
-    type D<G_Source, T_D> = T_D;
+    namespace dictionary {
+        namespace D {
+            type entry<G_Source, T_D> = T_D;
+            type location<G_Source, T_D> = G_Source;
+        }
+        type D<G_Source, T_D> = {
+            readonly 'entry': T_D;
+            readonly 'location': G_Source;
+        };
+    }
+    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+        readonly 'entry': T_D;
+        readonly 'location': G_Source;
+    }>;
+    type location<G_Source, T_D> = G_Source;
 }
 export declare namespace _T_List {
-    type L<G_Source, T_L> = T_L;
+    namespace list {
+        namespace L {
+            type element<G_Source, T_L> = T_L;
+            type location<G_Source, T_L> = G_Source;
+        }
+        type L<G_Source, T_L> = {
+            readonly 'element': T_L;
+            readonly 'location': G_Source;
+        };
+    }
+    type list<G_Source, T_L> = _pt.Array<{
+        readonly 'element': T_L;
+        readonly 'location': G_Source;
+    }>;
+    type location<G_Source, T_L> = G_Source;
 }
 export declare namespace _T_Ordered_Dictionary {
-    type D<G_Source, T_D> = T_D;
+    namespace dictionary {
+        namespace D {
+            type entry<G_Source, T_D> = T_D;
+            type location<G_Source, T_D> = G_Source;
+        }
+        type D<G_Source, T_D> = {
+            readonly 'entry': T_D;
+            readonly 'location': G_Source;
+        };
+    }
+    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+        readonly 'entry': T_D;
+        readonly 'location': G_Source;
+    }>;
+    type location<G_Source, T_D> = G_Source;
+}
+export declare namespace _T_Reference_To_Circular_Dependent_Sibling {
+    type key<G_Source, T_Dictionary_Entry> = string;
+    type location<G_Source, T_Dictionary_Entry> = G_Source;
+}
+export declare namespace _T_Reference_To_Normal_Dictionary_Entry {
+    type key<G_Source, T_Dictionary_Entry> = string;
+    type location<G_Source, T_Dictionary_Entry> = G_Source;
+}
+export declare namespace _T_Reference_To_Stacked_Dictionary_Entry {
+    type key<G_Source, T_Dictionary_Entry> = string;
+    type location<G_Source, T_Dictionary_Entry> = G_Source;
+    type up_steps<G_Source, T_Dictionary_Entry> = number;
+}
+export declare namespace _T_State_Group {
+    type location<G_Source, T_SG> = G_Source;
+    type state_group<G_Source, T_SG> = T_SG;
 }
 export declare namespace Dictionary {
-    type D<G_Source, T_D> = T_D;
+    namespace dictionary {
+        namespace D {
+            type entry<G_Source, T_D> = T_D;
+            type location<G_Source, T_D> = G_Source;
+        }
+        type D<G_Source, T_D> = {
+            readonly 'entry': T_D;
+            readonly 'location': G_Source;
+        };
+    }
+    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+        readonly 'entry': T_D;
+        readonly 'location': G_Source;
+    }>;
+    type location<G_Source, T_D> = G_Source;
 }
 export declare namespace List {
-    type L<G_Source, T_L> = T_L;
+    namespace list {
+        namespace L {
+            type element<G_Source, T_L> = T_L;
+            type location<G_Source, T_L> = G_Source;
+        }
+        type L<G_Source, T_L> = {
+            readonly 'element': T_L;
+            readonly 'location': G_Source;
+        };
+    }
+    type list<G_Source, T_L> = _pt.Array<{
+        readonly 'element': T_L;
+        readonly 'location': G_Source;
+    }>;
+    type location<G_Source, T_L> = G_Source;
 }
 export declare namespace Ordered_Dictionary {
-    type D<G_Source, T_D> = T_D;
+    namespace dictionary {
+        namespace D {
+            type entry<G_Source, T_D> = T_D;
+            type location<G_Source, T_D> = G_Source;
+        }
+        type D<G_Source, T_D> = {
+            readonly 'entry': T_D;
+            readonly 'location': G_Source;
+        };
+    }
+    type dictionary<G_Source, T_D> = _pt.Dictionary<{
+        readonly 'entry': T_D;
+        readonly 'location': G_Source;
+    }>;
+    type location<G_Source, T_D> = G_Source;
+}
+export declare namespace Reference_To_Circular_Dependent_Sibling {
+    type key<G_Source, T_Dictionary_Entry> = string;
+    type location<G_Source, T_Dictionary_Entry> = G_Source;
+}
+export declare namespace Reference_To_Normal_Dictionary_Entry {
+    type key<G_Source, T_Dictionary_Entry> = string;
+    type location<G_Source, T_Dictionary_Entry> = G_Source;
+}
+export declare namespace Reference_To_Stacked_Dictionary_Entry {
+    type key<G_Source, T_Dictionary_Entry> = string;
+    type location<G_Source, T_Dictionary_Entry> = G_Source;
+    type up_steps<G_Source, T_Dictionary_Entry> = number;
+}
+export declare namespace State_Group {
+    type location<G_Source, T_SG> = G_Source;
+    type state_group<G_Source, T_SG> = T_SG;
 }

package/dist/generated/interface/schemas/ast/marshall.d.ts

@@ -0,0 +1,226 @@
+import * as _i_in from "./unconstrained";
+import * as _i_out from "../../core/astn_target";
+export type _T_Value_Serializers = {
+    readonly 'boolean': ($$_: boolean, $$_p: null) => string;
+    readonly 'custom numbers': null;
+    readonly 'default number': ($$_: number, $$_p: null) => string;
+};
+export type _T_s_Document = ($$_: _i_in._T_Document, $$_p: {
+    readonly 'value serializers': _T_Value_Serializers;
+}) => _i_out._T_Value;
+export type _T_s_Elements = ($$_: _i_in._T_Elements, $$_p: {
+    readonly 'value serializers': _T_Value_Serializers;
+}) => _i_out._T_Value;
+export type _T_s_Key_Value_Pairs = ($$_: _i_in._T_Key_Value_Pairs, $$_p: {
+    readonly 'value serializers': _T_Value_Serializers;
+}) => _i_out._T_Value;
+export type _T_s_String = ($$_: _i_in._T_String, $$_p: {
+    readonly 'value serializers': _T_Value_Serializers;
+}) => _i_out._T_Value;
+export type _T_s_Structural_Token = ($$_: _i_in._T_Structural_Token, $$_p: {
+    readonly 'value serializers': _T_Value_Serializers;
+}) => _i_out._T_Value;
+export type _T_s_Value = ($$_: _i_in._T_Value, $$_p: {
+    readonly 'value serializers': _T_Value_Serializers;
+}) => _i_out._T_Value;
+export type Value_Serializers = _T_Value_Serializers;
+export type s_Document = _T_s_Document;
+export type s_Elements = _T_s_Elements;
+export type s_Key_Value_Pairs = _T_s_Key_Value_Pairs;
+export type s_String = _T_s_String;
+export type s_Structural_Token = _T_s_Structural_Token;
+export type s_Value = _T_s_Value;
+export declare namespace _T_Value_Serializers {
+    namespace _boolean {
+        type CONTEXT = boolean;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type _boolean = ($$_: boolean, $$_p: null) => string;
+    namespace custom_numbers {
+    }
+    type custom_numbers = null;
+    namespace default_number {
+        type CONTEXT = number;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type default_number = ($$_: number, $$_p: null) => string;
+}
+export declare namespace _T_s_Document {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Document;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace _T_s_Elements {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Elements;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace _T_s_Key_Value_Pairs {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Key_Value_Pairs;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace _T_s_String {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_String;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace _T_s_Structural_Token {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Structural_Token;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace _T_s_Value {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace Value_Serializers {
+    namespace _boolean {
+        type CONTEXT = boolean;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type _boolean = ($$_: boolean, $$_p: null) => string;
+    namespace custom_numbers {
+    }
+    type custom_numbers = null;
+    namespace default_number {
+        type CONTEXT = number;
+        namespace PARAMS {
+        }
+        type RESULT = string;
+    }
+    type default_number = ($$_: number, $$_p: null) => string;
+}
+export declare namespace s_Document {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Document;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace s_Elements {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Elements;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace s_Key_Value_Pairs {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Key_Value_Pairs;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace s_String {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_String;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace s_Structural_Token {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Structural_Token;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}
+export declare namespace s_Value {
+    namespace CONTEXT {
+    }
+    type CONTEXT = _i_in._T_Value;
+    namespace PARAMS {
+        namespace value_serializers {
+        }
+        type value_serializers = _T_Value_Serializers;
+    }
+    namespace RESULT {
+    }
+    type RESULT = _i_out._T_Value;
+}

package/dist/generated/interface/schemas/ast/marshall.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWFyc2hhbGwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2ludGVyZmFjZS9zY2hlbWFzL2FzdC9tYXJzaGFsbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=