astn 0.113.35 → 0.113.37

package/dist/interface/generated/{pareto → liana}/schemas/astn_schema/data/unresolved.d.ts

@@ -1,5 +1,5 @@
 import * as _pi from "pareto-core/dist/interface";
-import * as i__location from "../../../core/location";
+import * as i__location from "../../../generic/location";
 export declare namespace Schemas_ {
     type location = i__location.Location;
     namespace dictionary {
@@ -19,21 +19,21 @@ export type Schemas_ = {
     readonly 'dictionary': Schemas_.dictionary;
 };
 export declare namespace Text_Type_ {
-    namespace _type {
+    namespace type_ {
         type location = i__location.Location;
-        namespace state_group {
+        namespace state {
             type multi_line = null;
             type single_line = null;
         }
-        type state_group = readonly ['multi line', state_group.multi_line] | readonly ['single line', state_group.single_line];
+        type state = readonly ['multi line', state.multi_line] | readonly ['single line', state.single_line];
     }
-    type _type = {
-        readonly 'location': _type.location;
-        readonly 'state group': _type.state_group;
+    type type_ = {
+        readonly 'location': type_.location;
+        readonly 'state': type_.state;
     };
 }
 export type Text_Type_ = {
-    readonly 'type': Text_Type_._type;
+    readonly 'type': Text_Type_.type_;
 };
 export declare namespace Globals_ {
     namespace text_types {
@@ -94,15 +94,15 @@ export type Schema_ = {
 };
 export declare namespace Schema_Tree_ {
     type location = i__location.Location;
-    namespace state_group {
-        type _set = Schemas_;
+    namespace state {
+        type set_ = Schemas_;
         type schema = Schema_;
     }
-    type state_group = readonly ['set', state_group._set] | readonly ['schema', state_group.schema];
+    type state = readonly ['set', state.set_] | readonly ['schema', state.schema];
 }
 export type Schema_Tree_ = {
     readonly 'location': Schema_Tree_.location;
-    readonly 'state group': Schema_Tree_.state_group;
+    readonly 'state': Schema_Tree_.state;
 };
 export declare namespace Imports_ {
     type location = i__location.Location;
@@ -164,31 +164,31 @@ export type Group_ = {
 };
 export declare namespace Type_Node_ {
     type location = i__location.Location;
-    namespace state_group {
+    namespace state {
         namespace component {
             type location = i__location.Location;
-            namespace state_group {
+            namespace state {
                 namespace external {
-                    namespace _import {
+                    namespace import_ {
                         type location = i__location.Location;
                         type key = string;
                     }
-                    type _import = {
-                        readonly 'location': _import.location;
-                        readonly 'key': _import.key;
+                    type import_ = {
+                        readonly 'location': import_.location;
+                        readonly 'key': import_.key;
                     };
-                    namespace _type {
+                    namespace type_ {
                         type location = i__location.Location;
                         type key = string;
                     }
-                    type _type = {
-                        readonly 'location': _type.location;
-                        readonly 'key': _type.key;
+                    type type_ = {
+                        readonly 'location': type_.location;
+                        readonly 'key': type_.key;
                     };
                 }
                 type external = {
-                    readonly 'import': external._import;
-                    readonly 'type': external._type;
+                    readonly 'import': external.import_;
+                    readonly 'type': external.type_;
                 };
                 namespace internal {
                     type location = i__location.Location;
@@ -207,11 +207,11 @@ export declare namespace Type_Node_ {
                     readonly 'key': internal_cyclic.key;
                 };
             }
-            type state_group = readonly ['external', state_group.external] | readonly ['internal', state_group.internal] | readonly ['internal cyclic', state_group.internal_cyclic];
+            type state = readonly ['external', state.external] | readonly ['internal', state.internal] | readonly ['internal cyclic', state.internal_cyclic];
         }
         type component = {
             readonly 'location': component.location;
-            readonly 'state group': component.state_group;
+            readonly 'state': component.state;
         };
         type dictionary = Dictionary_;
         type group = Group_;
@@ -223,7 +223,7 @@ export declare namespace Type_Node_ {
         };
         type nothing = null;
         type optional = Type_Node_;
-        namespace state_group {
+        namespace state {
             type location = i__location.Location;
             namespace dictionary {
                 namespace D {
@@ -237,13 +237,13 @@ export declare namespace Type_Node_ {
             }
             type dictionary = _pi.Dictionary<dictionary.D>;
         }
-        type state_group = {
-            readonly 'location': state_group.location;
-            readonly 'dictionary': state_group.dictionary;
+        type state = {
+            readonly 'location': state.location;
+            readonly 'dictionary': state.dictionary;
         };
         namespace text {
             type location = i__location.Location;
-            namespace state_group {
+            namespace state {
                 namespace global {
                     type location = i__location.Location;
                     type key = string;
@@ -254,17 +254,17 @@ export declare namespace Type_Node_ {
                 };
                 type local = Text_Type_;
             }
-            type state_group = readonly ['global', state_group.global] | readonly ['local', state_group.local];
+            type state = readonly ['global', state.global] | readonly ['local', state.local];
         }
         type text = {
             readonly 'location': text.location;
-            readonly 'state group': text.state_group;
+            readonly 'state': text.state;
         };
     }
-    type state_group = readonly ['component', state_group.component] | readonly ['dictionary', state_group.dictionary] | readonly ['group', state_group.group] | readonly ['list', state_group.list] | readonly ['nothing', state_group.nothing] | readonly ['optional', state_group.optional] | readonly ['state group', state_group.state_group] | readonly ['text', state_group.text];
+    type state = readonly ['component', state.component] | readonly ['dictionary', state.dictionary] | readonly ['group', state.group] | readonly ['list', state.list] | readonly ['nothing', state.nothing] | readonly ['optional', state.optional] | readonly ['state', state.state] | readonly ['text', state.text];
 }
 export type Type_Node_ = {
     readonly 'location': Type_Node_.location;
-    readonly 'state group': Type_Node_.state_group;
+    readonly 'state': Type_Node_.state;
 };
 export { Schemas_ as Schemas, Text_Type_ as Text_Type, Globals_ as Globals, Type_ as Type, Types_ as Types, Schema_ as Schema, Schema_Tree_ as Schema_Tree, Imports_ as Imports, Dictionary_ as Dictionary, Group_ as Group, Type_Node_ as Type_Node, };

package/dist/interface/generated/{pareto → liana}/schemas/astn_schema/data/unresolved.js

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

package/dist/interface/generated/liana/schemas/astn_schema/deserialize.d.ts

@@ -0,0 +1,79 @@
+import * as i_out from "./data/unresolved";
+export declare namespace Schemas_ {
+    type I = string;
+    type O = i_out.Schemas;
+    namespace P {
+    }
+}
+export type Schemas_ = (context: Schemas_.I) => Schemas_.O;
+export declare namespace Text_Type_ {
+    type I = string;
+    type O = i_out.Text_Type;
+    namespace P {
+    }
+}
+export type Text_Type_ = (context: Text_Type_.I) => Text_Type_.O;
+export declare namespace Globals_ {
+    type I = string;
+    type O = i_out.Globals;
+    namespace P {
+    }
+}
+export type Globals_ = (context: Globals_.I) => Globals_.O;
+export declare namespace Type_ {
+    type I = string;
+    type O = i_out.Type;
+    namespace P {
+    }
+}
+export type Type_ = (context: Type_.I) => Type_.O;
+export declare namespace Types_ {
+    type I = string;
+    type O = i_out.Types;
+    namespace P {
+    }
+}
+export type Types_ = (context: Types_.I) => Types_.O;
+export declare namespace Schema_ {
+    type I = string;
+    type O = i_out.Schema;
+    namespace P {
+    }
+}
+export type Schema_ = (context: Schema_.I) => Schema_.O;
+export declare namespace Schema_Tree_ {
+    type I = string;
+    type O = i_out.Schema_Tree;
+    namespace P {
+    }
+}
+export type Schema_Tree_ = (context: Schema_Tree_.I) => Schema_Tree_.O;
+export declare namespace Imports_ {
+    type I = string;
+    type O = i_out.Imports;
+    namespace P {
+    }
+}
+export type Imports_ = (context: Imports_.I) => Imports_.O;
+export declare namespace Dictionary_ {
+    type I = string;
+    type O = i_out.Dictionary;
+    namespace P {
+    }
+}
+export type Dictionary_ = (context: Dictionary_.I) => Dictionary_.O;
+export declare namespace Group_ {
+    type I = string;
+    type O = i_out.Group;
+    namespace P {
+    }
+}
+export type Group_ = (context: Group_.I) => Group_.O;
+export declare namespace Type_Node_ {
+    type I = string;
+    type O = i_out.Type_Node;
+    namespace P {
+    }
+}
+export type Type_Node_ = (context: Type_Node_.I) => Type_Node_.O;
+export { Schemas_ as Schemas, Text_Type_ as Text_Type, Globals_ as Globals, Type_ as Type, Types_ as Types, Schema_ as Schema, Schema_Tree_ as Schema_Tree, Imports_ as Imports, Dictionary_ as Dictionary, Group_ as Group, Type_Node_ as Type_Node, };

package/dist/interface/generated/liana/schemas/astn_schema/deserialize.js

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

package/dist/interface/generated/liana/schemas/astn_schema/marshall.d.ts

@@ -0,0 +1,80 @@
+import * as i_out from "astn-core/dist/interface/generated/liana/schemas/sealed_target/data";
+import * as i_in from "./data/resolved";
+export declare namespace Schemas_ {
+    type I = i_in.Schemas;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Schemas_ = (context: Schemas_.I) => Schemas_.O;
+export declare namespace Text_Type_ {
+    type I = i_in.Text_Type;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Text_Type_ = (context: Text_Type_.I) => Text_Type_.O;
+export declare namespace Globals_ {
+    type I = i_in.Globals;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Globals_ = (context: Globals_.I) => Globals_.O;
+export declare namespace Type_ {
+    type I = i_in.Type;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Type_ = (context: Type_.I) => Type_.O;
+export declare namespace Types_ {
+    type I = i_in.Types;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Types_ = (context: Types_.I) => Types_.O;
+export declare namespace Schema_ {
+    type I = i_in.Schema;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Schema_ = (context: Schema_.I) => Schema_.O;
+export declare namespace Schema_Tree_ {
+    type I = i_in.Schema_Tree;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Schema_Tree_ = (context: Schema_Tree_.I) => Schema_Tree_.O;
+export declare namespace Imports_ {
+    type I = i_in.Imports;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Imports_ = (context: Imports_.I) => Imports_.O;
+export declare namespace Dictionary_ {
+    type I = i_in.Dictionary;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Dictionary_ = (context: Dictionary_.I) => Dictionary_.O;
+export declare namespace Group_ {
+    type I = i_in.Group;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Group_ = (context: Group_.I) => Group_.O;
+export declare namespace Type_Node_ {
+    type I = i_in.Type_Node;
+    type O = i_out.Value;
+    namespace P {
+    }
+}
+export type Type_Node_ = (context: Type_Node_.I) => Type_Node_.O;
+export { Schemas_ as Schemas, Text_Type_ as Text_Type, Globals_ as Globals, Type_ as Type, Types_ as Types, Schema_ as Schema, Schema_Tree_ as Schema_Tree, Imports_ as Imports, Dictionary_ as Dictionary, Group_ as Group, Type_Node_ as Type_Node, };

package/dist/interface/generated/liana/schemas/astn_schema/marshall.js

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

package/dist/interface/generated/{pareto → liana}/schemas/astn_schema/migrate_boilerplate.d.ts

@@ -6,75 +6,75 @@ export declare namespace Schemas_ {
     namespace P {
     }
 }
-export type Schemas_ = ($$_: Schemas_.I) => Schemas_.O;
+export type Schemas_ = (context: Schemas_.I) => Schemas_.O;
 export declare namespace Text_Type_ {
     type I = i_in.Text_Type;
     type O = i_out.Text_Type;
     namespace P {
     }
 }
-export type Text_Type_ = ($$_: Text_Type_.I) => Text_Type_.O;
+export type Text_Type_ = (context: Text_Type_.I) => Text_Type_.O;
 export declare namespace Globals_ {
     type I = i_in.Globals;
     type O = i_out.Globals;
     namespace P {
     }
 }
-export type Globals_ = ($$_: Globals_.I) => Globals_.O;
+export type Globals_ = (context: Globals_.I) => Globals_.O;
 export declare namespace Type_ {
     type I = i_in.Type;
     type O = i_out.Type;
     namespace P {
     }
 }
-export type Type_ = ($$_: Type_.I) => Type_.O;
+export type Type_ = (context: Type_.I) => Type_.O;
 export declare namespace Types_ {
     type I = i_in.Types;
     type O = i_out.Types;
     namespace P {
     }
 }
-export type Types_ = ($$_: Types_.I) => Types_.O;
+export type Types_ = (context: Types_.I) => Types_.O;
 export declare namespace Schema_ {
     type I = i_in.Schema;
     type O = i_out.Schema;
     namespace P {
     }
 }
-export type Schema_ = ($$_: Schema_.I) => Schema_.O;
+export type Schema_ = (context: Schema_.I) => Schema_.O;
 export declare namespace Schema_Tree_ {
     type I = i_in.Schema_Tree;
     type O = i_out.Schema_Tree;
     namespace P {
     }
 }
-export type Schema_Tree_ = ($$_: Schema_Tree_.I) => Schema_Tree_.O;
+export type Schema_Tree_ = (context: Schema_Tree_.I) => Schema_Tree_.O;
 export declare namespace Imports_ {
     type I = i_in.Imports;
     type O = i_out.Imports;
     namespace P {
     }
 }
-export type Imports_ = ($$_: Imports_.I) => Imports_.O;
+export type Imports_ = (context: Imports_.I) => Imports_.O;
 export declare namespace Dictionary_ {
     type I = i_in.Dictionary;
     type O = i_out.Dictionary;
     namespace P {
     }
 }
-export type Dictionary_ = ($$_: Dictionary_.I) => Dictionary_.O;
+export type Dictionary_ = (context: Dictionary_.I) => Dictionary_.O;
 export declare namespace Group_ {
     type I = i_in.Group;
     type O = i_out.Group;
     namespace P {
     }
 }
-export type Group_ = ($$_: Group_.I) => Group_.O;
+export type Group_ = (context: Group_.I) => Group_.O;
 export declare namespace Type_Node_ {
     type I = i_in.Type_Node;
     type O = i_out.Type_Node;
     namespace P {
     }
 }
-export type Type_Node_ = ($$_: Type_Node_.I) => Type_Node_.O;
+export type Type_Node_ = (context: Type_Node_.I) => Type_Node_.O;
 export { Schemas_ as Schemas, Text_Type_ as Text_Type, Globals_ as Globals, Type_ as Type, Types_ as Types, Schema_ as Schema, Schema_Tree_ as Schema_Tree, Imports_ as Imports, Dictionary_ as Dictionary, Group_ as Group, Type_Node_ as Type_Node, };

package/dist/interface/generated/{pareto → liana}/schemas/astn_schema/migrate_boilerplate.js

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

package/dist/interface/generated/{pareto → liana}/schemas/astn_schema/resolve.d.ts

@@ -1,23 +1,27 @@
 import * as _pi from "pareto-core/dist/interface";
+import * as i_generic from "../../generic/resolve";
 import * as i_resolved from "./data/resolved";
 import * as i_unresolved from "./data/unresolved";
 export declare namespace Text_Type_ {
     type I = i_unresolved.Text_Type;
     type O = i_resolved.Text_Type;
+    type E = i_generic.Error;
     namespace P {
     }
 }
-export type Text_Type_ = ($$_: Text_Type_.I, $$_lookups: null, $$_p: null) => Text_Type_.O;
+export type Text_Type_ = (context: Text_Type_.I, abort: _pi.Abort<Text_Type_.E>, lookups: null, parameters: null) => Text_Type_.O;
 export declare namespace Globals_ {
     type I = i_unresolved.Globals;
     type O = i_resolved.Globals;
+    type E = i_generic.Error;
     namespace P {
     }
 }
-export type Globals_ = ($$_: Globals_.I, $$_lookups: null, $$_p: null) => Globals_.O;
+export type Globals_ = (context: Globals_.I, abort: _pi.Abort<Globals_.E>, lookups: null, parameters: null) => Globals_.O;
 export declare namespace Group_ {
     type I = i_unresolved.Group;
     type O = i_resolved.Group;
+    type E = i_generic.Error;
     namespace L {
         type noncircular_sibling_types = i_resolved.Types_.D;
     }
@@ -35,16 +39,17 @@ export declare namespace Group_ {
         type imports = _pi.Optional_Value<imports.O>;
     }
 }
-export type Group_ = ($$_: Group_.I, $$_lookups: {
+export type Group_ = (context: Group_.I, abort: _pi.Abort<Group_.E>, lookups: {
     readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Group_.L.noncircular_sibling_types>;
     readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Group_.L.possibly_circular_dependent_sibling_types>;
-}, $$_p: {
+}, parameters: {
     readonly 'globals': Group_.P.globals;
     readonly 'imports': Group_.P.imports;
 }) => Group_.O;
 export declare namespace Dictionary_ {
     type I = i_unresolved.Dictionary;
     type O = i_resolved.Dictionary;
+    type E = i_generic.Error;
     namespace L {
         type noncircular_sibling_types = i_resolved.Types_.D;
     }
@@ -62,16 +67,17 @@ export declare namespace Dictionary_ {
         type imports = _pi.Optional_Value<imports.O>;
     }
 }
-export type Dictionary_ = ($$_: Dictionary_.I, $$_lookups: {
+export type Dictionary_ = (context: Dictionary_.I, abort: _pi.Abort<Dictionary_.E>, lookups: {
     readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Dictionary_.L.noncircular_sibling_types>;
     readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Dictionary_.L.possibly_circular_dependent_sibling_types>;
-}, $$_p: {
+}, parameters: {
     readonly 'globals': Dictionary_.P.globals;
     readonly 'imports': Dictionary_.P.imports;
 }) => Dictionary_.O;
 export declare namespace Type_Node_ {
     type I = i_unresolved.Type_Node;
     type O = i_resolved.Type_Node;
+    type E = i_generic.Error;
     namespace L {
         type noncircular_sibling_types = i_resolved.Types_.D;
     }
@@ -89,16 +95,17 @@ export declare namespace Type_Node_ {
         type imports = _pi.Optional_Value<imports.O>;
     }
 }
-export type Type_Node_ = ($$_: Type_Node_.I, $$_lookups: {
+export type Type_Node_ = (context: Type_Node_.I, abort: _pi.Abort<Type_Node_.E>, lookups: {
     readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Type_Node_.L.noncircular_sibling_types>;
     readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Type_Node_.L.possibly_circular_dependent_sibling_types>;
-}, $$_p: {
+}, parameters: {
     readonly 'globals': Type_Node_.P.globals;
     readonly 'imports': Type_Node_.P.imports;
 }) => Type_Node_.O;
 export declare namespace Type_ {
     type I = i_unresolved.Type;
     type O = i_resolved.Type;
+    type E = i_generic.Error;
     namespace L {
         type noncircular_sibling_types = i_resolved.Types_.D;
     }
@@ -116,64 +123,69 @@ export declare namespace Type_ {
         type imports = _pi.Optional_Value<imports.O>;
     }
 }
-export type Type_ = ($$_: Type_.I, $$_lookups: {
+export type Type_ = (context: Type_.I, abort: _pi.Abort<Type_.E>, lookups: {
     readonly 'noncircular sibling types': _pi.Acyclic_Lookup<Type_.L.noncircular_sibling_types>;
     readonly 'possibly circular dependent sibling types': _pi.Cyclic_Lookup<Type_.L.possibly_circular_dependent_sibling_types>;
-}, $$_p: {
+}, parameters: {
     readonly 'globals': Type_.P.globals;
     readonly 'imports': Type_.P.imports;
 }) => Type_.O;
 export declare namespace Schemas_ {
     type I = i_unresolved.Schemas;
     type O = i_resolved.Schemas;
+    type E = i_generic.Error;
     namespace L {
         type sibling_schemas = i_resolved.Schemas_.D;
     }
     namespace P {
     }
 }
-export type Schemas_ = ($$_: Schemas_.I, $$_lookups: {
+export type Schemas_ = (context: Schemas_.I, abort: _pi.Abort<Schemas_.E>, lookups: {
     readonly 'sibling schemas': _pi.Stack_Lookup<Schemas_.L.sibling_schemas>;
-}, $$_p: null) => Schemas_.O;
+}, parameters: null) => Schemas_.O;
 export declare namespace Schema_Tree_ {
     type I = i_unresolved.Schema_Tree;
     type O = i_resolved.Schema_Tree;
+    type E = i_generic.Error;
     namespace L {
         type sibling_schemas = i_resolved.Schemas_.D;
     }
     namespace P {
     }
 }
-export type Schema_Tree_ = ($$_: Schema_Tree_.I, $$_lookups: {
+export type Schema_Tree_ = (context: Schema_Tree_.I, abort: _pi.Abort<Schema_Tree_.E>, lookups: {
     readonly 'sibling schemas': _pi.Stack_Lookup<Schema_Tree_.L.sibling_schemas>;
-}, $$_p: null) => Schema_Tree_.O;
+}, parameters: null) => Schema_Tree_.O;
 export declare namespace Schema_ {
     type I = i_unresolved.Schema;
     type O = i_resolved.Schema;
+    type E = i_generic.Error;
     namespace L {
         type sibling_schemas = i_resolved.Schemas_.D;
     }
     namespace P {
     }
 }
-export type Schema_ = ($$_: Schema_.I, $$_lookups: {
+export type Schema_ = (context: Schema_.I, abort: _pi.Abort<Schema_.E>, lookups: {
     readonly 'sibling schemas': _pi.Stack_Lookup<Schema_.L.sibling_schemas>;
-}, $$_p: null) => Schema_.O;
+}, parameters: null) => Schema_.O;
 export declare namespace Imports_ {
     type I = i_unresolved.Imports;
     type O = i_resolved.Imports;
+    type E = i_generic.Error;
     namespace L {
         type sibling_schemas = i_resolved.Schemas_.D;
     }
     namespace P {
     }
 }
-export type Imports_ = ($$_: Imports_.I, $$_lookups: {
+export type Imports_ = (context: Imports_.I, abort: _pi.Abort<Imports_.E>, lookups: {
     readonly 'sibling schemas': _pi.Stack_Lookup<Imports_.L.sibling_schemas>;
-}, $$_p: null) => Imports_.O;
+}, parameters: null) => Imports_.O;
 export declare namespace Types_ {
     type I = i_unresolved.Types;
     type O = i_resolved.Types;
+    type E = i_generic.Error;
     namespace P {
         namespace globals {
             type O = i_resolved.Globals_;
@@ -185,7 +197,7 @@ export declare namespace Types_ {
         type imports = _pi.Optional_Value<imports.O>;
     }
 }
-export type Types_ = ($$_: Types_.I, $$_lookups: null, $$_p: {
+export type Types_ = (context: Types_.I, abort: _pi.Abort<Types_.E>, lookups: null, parameters: {
     readonly 'globals': Types_.P.globals;
     readonly 'imports': Types_.P.imports;
 }) => Types_.O;

package/dist/interface/generated/liana/schemas/astn_schema/resolve.js

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