astn 0.113.27 → 0.113.29

package/dist/interface/generated/pareto/schemas/astn_schema/data_types/resolve.d.ts

@@ -1,1125 +1,192 @@
 import * as _pi from "pareto-core-interface";
-import * as _i_resolve from "pareto-core-internals/dist/algorithm_types/refiner/resolve";
-import * as _i_resolved from "./source";
-import * as _i_unresolved from "./target";
-export type _T_Text_Type = <F_Source>($$_: _i_unresolved._T_Text_Type<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': null;
-        readonly 'lookups': null;
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Text_Type;
-export type _T_Globals = <F_Source>($$_: _i_unresolved._T_Globals<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': null;
-        readonly 'lookups': null;
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Globals;
-export type _T_Group = <F_Source>($$_: _i_unresolved._T_Group<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': {
-            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-        };
-        readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Group;
-export type _T_Dictionary = <F_Source>($$_: _i_unresolved._T_Dictionary<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': {
-            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-        };
-        readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Dictionary;
-export type _T_Type_Node = <F_Source>($$_: _i_unresolved._T_Type_Node<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': {
-            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-        };
-        readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Type_Node;
-export type _T_Type = <F_Source>($$_: _i_unresolved._T_Type<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': {
-            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-        };
-        readonly 'lookups': {
-            readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-            readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Type;
-export type _T_Schemas = <F_Source>($$_: _i_unresolved._T_Schemas<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': null;
-        readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Schemas;
-export type _T_Schema_Tree = <F_Source>($$_: _i_unresolved._T_Schema_Tree<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': null;
-        readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Schema_Tree;
-export type _T_Schema = <F_Source>($$_: _i_unresolved._T_Schema<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': null;
-        readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Schema;
-export type _T_Imports = <F_Source>($$_: _i_unresolved._T_Imports<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': null;
-        readonly 'lookups': {
-            readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-        };
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Imports;
-export type _T_Types = <F_Source>($$_: _i_unresolved._T_Types<F_Source>, $$_p: {
-    readonly 'parameters': {
-        readonly 'values': {
-            readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-            readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-        };
-        readonly 'lookups': null;
-    };
-    readonly 'location 2 string': _i_resolve._T_Location_2_String<F_Source>;
-}) => _i_resolved._T_Types;
-export type Text_Type = _T_Text_Type;
-export type Globals = _T_Globals;
-export type Group = _T_Group;
-export type Dictionary = _T_Dictionary;
-export type Type_Node = _T_Type_Node;
-export type Type = _T_Type;
-export type Schemas = _T_Schemas;
-export type Schema_Tree = _T_Schema_Tree;
-export type Schema = _T_Schema;
-export type Imports = _T_Imports;
-export type Types = _T_Types;
-export declare namespace _T_Text_Type {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Text_Type<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': null;
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Text_Type;
-}
-export declare namespace _T_Globals {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Globals<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': null;
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Globals;
-}
-export declare namespace _T_Group {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Group<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Group;
-}
-export declare namespace _T_Dictionary {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Dictionary<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Dictionary;
-}
-export declare namespace _T_Type_Node {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type_Node<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Type_Node;
-}
-export declare namespace _T_Type {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Type;
-}
-export declare namespace _T_Schemas {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schemas<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schemas;
-}
-export declare namespace _T_Schema_Tree {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schema_Tree<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schema_Tree;
-}
-export declare namespace _T_Schema {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schema<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schema;
-}
-export declare namespace _T_Imports {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Imports<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Imports;
-}
-export declare namespace _T_Types {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Types<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': null;
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Types;
-}
-export declare namespace Text_Type {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Text_Type<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': null;
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Text_Type;
-}
-export declare namespace Globals {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Globals<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': null;
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Globals;
-}
-export declare namespace Group {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Group<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Group;
-}
-export declare namespace Dictionary {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Dictionary<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Dictionary;
-}
-export declare namespace Type_Node {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type_Node<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Type_Node;
-}
-export declare namespace Type {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Type<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-                namespace noncircular_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type noncircular_sibling_types<F_Source> = _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                namespace possibly_circular_dependent_sibling_types {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Types.D;
-                }
-                type possibly_circular_dependent_sibling_types<F_Source> = _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': {
-                readonly 'noncircular sibling types': _i_resolve._T_Acyclic_Lookup<_i_resolved._T_Types.D>;
-                readonly 'possibly circular dependent sibling types': _i_resolve._T_Cyclic_Lookup<_i_resolved._T_Types.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Type;
-}
-export declare namespace Schemas {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schemas<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schemas;
-}
-export declare namespace Schema_Tree {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schema_Tree<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schema_Tree;
-}
-export declare namespace Schema {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Schema<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Schema;
-}
-export declare namespace Imports {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Imports<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-            }
-            type values<F_Source> = null;
-            namespace lookups {
-                namespace sibling_schemas {
-                    namespace T {
-                    }
-                    type T<F_Source> = _i_resolved._T_Schemas.D;
-                }
-                type sibling_schemas<F_Source> = _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            }
-            type lookups<F_Source> = {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        }
-        type parameters<F_Source> = {
-            readonly 'values': null;
-            readonly 'lookups': {
-                readonly 'sibling schemas': _i_resolve._T_Lookup_Stack<_i_resolved._T_Schemas.D>;
-            };
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Imports;
-}
-export declare namespace Types {
-    namespace CONTEXT {
-        type Source<F_Source> = F_Source;
-    }
-    type CONTEXT<F_Source> = _i_unresolved._T_Types<F_Source>;
-    namespace PARAMS {
-        namespace parameters {
-            namespace values {
-                namespace globals {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Globals;
-                }
-                type globals<F_Source> = _pi.Optional_Value<_i_resolved._T_Globals>;
-                namespace imports {
-                    namespace O {
-                    }
-                    type O<F_Source> = _i_resolved._T_Imports;
-                }
-                type imports<F_Source> = _pi.Optional_Value<_i_resolved._T_Imports>;
-            }
-            type values<F_Source> = {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            namespace lookups {
-            }
-            type lookups<F_Source> = null;
-        }
-        type parameters<F_Source> = {
-            readonly 'values': {
-                readonly 'globals': _pi.Optional_Value<_i_resolved._T_Globals>;
-                readonly 'imports': _pi.Optional_Value<_i_resolved._T_Imports>;
-            };
-            readonly 'lookups': null;
-        };
-        namespace location_2_string {
-            type Source<F_Source> = F_Source;
-        }
-        type location_2_string<F_Source> = _i_resolve._T_Location_2_String<F_Source>;
-    }
-    namespace RESULT {
-    }
-    type RESULT<F_Source> = _i_resolved._T_Types;
-}
+import * as i_resolved from "./source";
+import * as i_unresolved from "./target";
+export declare namespace Text_Type_ {
+    type I = i_unresolved.Text_Type;
+    type O = i_resolved.Text_Type;
+    namespace P {
+    }
+}
+export type Text_Type_ = ($$_: Text_Type_.I, $$_lookups: null, $$_p: null) => Text_Type_.O;
+export declare namespace Globals_ {
+    type I = i_unresolved.Globals;
+    type O = i_resolved.Globals;
+    namespace P {
+    }
+}
+export type Globals_ = ($$_: Globals_.I, $$_lookups: null, $$_p: null) => Globals_.O;
+export declare namespace Group_ {
+    type I = i_unresolved.Group;
+    type O = i_resolved.Group;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Group_ = ($$_: Group_.I, $$_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: {
+    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;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Dictionary_ = ($$_: Dictionary_.I, $$_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: {
+    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;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Type_Node_ = ($$_: Type_Node_.I, $$_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: {
+    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;
+    namespace L {
+        type noncircular_sibling_types = i_resolved.Types_.D;
+    }
+    namespace L {
+        type possibly_circular_dependent_sibling_types = i_resolved.Types_.D;
+    }
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Type_ = ($$_: Type_.I, $$_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: {
+    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;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Schemas_ = ($$_: Schemas_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Schemas_.L.sibling_schemas>;
+}, $$_p: null) => Schemas_.O;
+export declare namespace Schema_Tree_ {
+    type I = i_unresolved.Schema_Tree;
+    type O = i_resolved.Schema_Tree;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Schema_Tree_ = ($$_: Schema_Tree_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Schema_Tree_.L.sibling_schemas>;
+}, $$_p: null) => Schema_Tree_.O;
+export declare namespace Schema_ {
+    type I = i_unresolved.Schema;
+    type O = i_resolved.Schema;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Schema_ = ($$_: Schema_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Schema_.L.sibling_schemas>;
+}, $$_p: null) => Schema_.O;
+export declare namespace Imports_ {
+    type I = i_unresolved.Imports;
+    type O = i_resolved.Imports;
+    namespace L {
+        type sibling_schemas = i_resolved.Schemas_.D;
+    }
+    namespace P {
+    }
+}
+export type Imports_ = ($$_: Imports_.I, $$_lookups: {
+    readonly 'sibling schemas': _pi.Stack_Lookup<Imports_.L.sibling_schemas>;
+}, $$_p: null) => Imports_.O;
+export declare namespace Types_ {
+    type I = i_unresolved.Types;
+    type O = i_resolved.Types;
+    namespace P {
+        namespace globals {
+            type O = i_resolved.Globals_;
+        }
+        type globals = _pi.Optional_Value<globals.O>;
+        namespace imports {
+            type O = i_resolved.Imports_;
+        }
+        type imports = _pi.Optional_Value<imports.O>;
+    }
+}
+export type Types_ = ($$_: Types_.I, $$_lookups: null, $$_p: {
+    readonly 'globals': Types_.P.globals;
+    readonly 'imports': Types_.P.imports;
+}) => Types_.O;
+export { Text_Type_ as Text_Type, Globals_ as Globals, Group_ as Group, Dictionary_ as Dictionary, Type_Node_ as Type_Node, Type_ as Type, Schemas_ as Schemas, Schema_Tree_ as Schema_Tree, Schema_ as Schema, Imports_ as Imports, Types_ as Types, };