pareto-liana 0.0.0 → 0.0.3

package/dist/shorthands/schema.d.ts

@@ -1,5 +1,6 @@
 import * as _p from 'pareto-core-shorthands/dist/unresolved_data';
-import * as d_schema from "../interface/generated/pareto/schemas/schema/data/unresolved";
+import * as sh from 'pareto-core-shorthands/dist/unresolved_data';
+import * as d_schema from "../interface/generated/liana/schemas/schema/data/unresolved";
 /**
  * schema tree
  */
@@ -7,111 +8,121 @@ export declare namespace st {
     const set: (schemas: _p.Raw_Or_Normal_Dictionary<d_schema.Schema_Tree>) => d_schema.Schema_Tree;
     const schema: (schema: d_schema.Schema) => d_schema.Schema_Tree;
 }
-export declare const types: (types: _p.Raw_Or_Normal_Dictionary<d_schema.Types.dictionary.D.entry>) => d_schema.Types;
-export declare const globals: (complexity: "unconstrained" | "constrained", text_types: _p.Raw_Or_Normal_Dictionary<d_schema.Globals.text_types.dictionary.D.entry>, number_types: _p.Raw_Or_Normal_Dictionary<d_schema.Globals.number_types.dictionary.D.entry>) => d_schema.Globals;
-export declare const type: (type: d_schema.Type_Node) => d_schema.Types.dictionary.D.entry;
+export declare const modules: (modules: _p.Raw_Or_Normal_Dictionary<d_schema.Modules.l_dictionary.D.l_entry>) => d_schema.Modules;
+export declare const globals: (complexity: "unconstrained" | "constrained", text_types: _p.Raw_Or_Normal_Dictionary<d_schema.Globals.text_types.l_dictionary.D.l_entry>, number_types: _p.Raw_Or_Normal_Dictionary<d_schema.Globals.number_types.l_dictionary.D.l_entry>) => d_schema.Globals;
+export declare const module_: (type: d_schema.Value) => d_schema.Modules.l_dictionary.D.l_entry;
 export declare const text: (type: "single line" | "multi line") => d_schema.Text_Type;
-export declare const prop: (node: d_schema.Type_Node) => d_schema.Group.dictionary.D.entry;
-export declare const tstate: (node: d_schema.Type_Node) => d_schema.Type_Node.state_group.state_group.dictionary.D.entry;
-export declare const tstated: (description: string, node: d_schema.Type_Node) => d_schema.Type_Node.state_group.state_group.dictionary.D.entry;
-export declare const propd: (description: string, node: d_schema.Type_Node) => d_schema.Group.dictionary.D.entry;
+export declare const prop: (node: d_schema.Value) => d_schema.Group.l_dictionary.D.l_entry;
+export declare const toption: (node: d_schema.Value) => d_schema.Value.l_state.state.options.l_dictionary.D.l_entry;
+export declare const toption_constrained: (constraints: _p.Raw_Or_Normal_Dictionary<d_schema.Option_Constraints.O.l_dictionary.D.l_entry>, node: d_schema.Value) => d_schema.Value.l_state.state.options.l_dictionary.D.l_entry;
+export declare const toption_with_description: (description: string, node: d_schema.Value) => d_schema.Value.l_state.state.options.l_dictionary.D.l_entry;
+export declare const prop_with_description: (description: string, node: d_schema.Value) => d_schema.Group.l_dictionary.D.l_entry;
 /**
  * number type
  */
 export declare namespace n {
-    const integer: (decimal_separator_offset?: number) => d_schema.Number_Type;
+    const integer: (decimal_separator_offset: null | number) => d_schema.Number_Type;
     const approximation: (significant_digits: number) => d_schema.Number_Type;
-    const natural: (decimal_separator_offset?: number) => d_schema.Number_Type;
-    const positive_natural: (decimal_separator_offset?: number) => d_schema.Number_Type;
+    const natural: (decimal_separator_offset: null | number) => d_schema.Number_Type;
+    const positive_natural: (decimal_separator_offset: null | number) => d_schema.Number_Type;
 }
-export declare const reference: (type: string) => d_schema.Type_Reference;
-export declare const part_reference: (type: string, tail: d_schema.Type_Node_Reference.tail.list.L.element[]) => d_schema.Type_Node_Reference;
+export declare const module_reference: (type: string) => d_schema.Module_Reference;
+export declare const value_reference: (type: string, tail: d_schema.Value_Path.tail.l_list.L.l_item[]) => d_schema.Value_Reference;
 /**
  * type node
  */
 export declare namespace t {
-    const boolean: () => d_schema.Type_Node;
-    const component: (type: string) => d_schema.Type_Node;
-    const component_cyclic: (type: string) => d_schema.Type_Node;
-    const component_external: (imp: string, type: string) => d_schema.Type_Node;
-    const dictionary: (type: d_schema.Type_Node, ordered?: "ordered" | "") => d_schema.Type_Node;
-    const group: (properties: _p.Raw_Or_Normal_Dictionary<d_schema.Group.dictionary.D.entry>) => d_schema.Type_Node;
-    const list: (type: d_schema.Type_Node) => d_schema.Type_Node;
-    const nothing: () => d_schema.Type_Node;
-    const number_global: (name: string) => d_schema.Type_Node;
-    const number_local: (bt: d_schema.Number_Type) => d_schema.Type_Node;
-    const optional: (type: d_schema.Type_Node) => d_schema.Type_Node;
-    const reference_derived: (type: string, tail: d_schema.Type_Node_Reference.tail.list.L.element[]) => d_schema.Type_Node;
-    const reference_derived_external: (imp: string, type: string, tail: d_schema.Type_Node_Reference.tail.list.L.element[]) => d_schema.Type_Node;
-    const reference: (type: string, tail: d_schema.Type_Node_Reference.tail.list.L.element[], dependency?: "cyclic" | "acyclic") => d_schema.Type_Node;
-    const reference_stack: (type: string, tail: d_schema.Type_Node_Reference.tail.list.L.element[]) => d_schema.Type_Node;
-    const reference_external: (schema: string, type: string, tail: d_schema.Type_Node_Reference.tail.list.L.element[]) => d_schema.Type_Node;
-    const state_group: (states: _p.Raw_Or_Normal_Dictionary<d_schema.Type_Node.state_group.state_group.dictionary.D.entry>) => d_schema.Type_Node;
-    const text_global: (name: string) => d_schema.Type_Node;
-    const text_local: (bt: d_schema.Text_Type) => d_schema.Type_Node;
+    const boolean: () => d_schema.Value;
+    const component_acyclic: (type: string) => d_schema.Value;
+    const component_with_results: (type: string, results: sh.Raw_Or_Normal_Dictionary<d_schema.Value_Results.O.l_dictionary.D.l_entry>) => d_schema.Value;
+    const component: (type: string) => d_schema.Value;
+    const component_external: (imp: string, type: string) => d_schema.Value;
+    const dictionary: (type: d_schema.Value) => d_schema.Value;
+    const group: (properties: _p.Raw_Or_Normal_Dictionary<d_schema.Group.l_dictionary.D.l_entry>) => d_schema.Value;
+    const list: (type: d_schema.Value) => d_schema.Value;
+    const list_with_results: (type: d_schema.Value, results: sh.Raw_Or_Normal_Dictionary<d_schema.Value_Results.O.l_dictionary.D.l_entry>) => d_schema.Value;
+    const nothing: () => d_schema.Value;
+    const number_global: (name: string) => d_schema.Value;
+    const number_local: (bt: d_schema.Number_Type) => d_schema.Value;
+    const optional: (type: d_schema.Value) => d_schema.Value;
+    const reference_derived: (type: string, tail: d_schema.Value_Path.tail.l_list.L.l_item[]) => d_schema.Value;
+    const reference_derived_external: (imp: string, type: string, tail: d_schema.Value_Path.tail.l_list.L.l_item[]) => d_schema.Value;
+    const reference: (type: string, tail: d_schema.Value_Path.tail.l_list.L.l_item[], dependency?: "cyclic" | "acyclic") => d_schema.Value;
+    const reference_stack: (type: string, tail: d_schema.Value_Path.tail.l_list.L.l_item[]) => d_schema.Value;
+    const reference_external: (schema: string, type: string, tail: d_schema.Value_Path.tail.l_list.L.l_item[]) => d_schema.Value;
+    const state: (options: _p.Raw_Or_Normal_Dictionary<d_schema.Value.l_state.state.options.l_dictionary.D.l_entry>) => d_schema.Value;
+    const state_with_result: (options: _p.Raw_Or_Normal_Dictionary<d_schema.Value.l_state.state.options.l_dictionary.D.l_entry>, results: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Results.O.l_dictionary.D.l_entry>) => d_schema.Value;
+    const text_global: (name: string) => d_schema.Value;
+    const text_local: (bt: d_schema.Text_Type) => d_schema.Value;
 }
 /**
- * type node reference tail step
+ * Value Path tail step
  */
-export declare namespace tr {
-    const d: () => d_schema.Type_Node_Reference.tail.list.L.element;
-    const g: (grp: string) => d_schema.Type_Node_Reference.tail.list.L.element;
-    const s: (state: string) => d_schema.Type_Node_Reference.tail.list.L.element;
-    const o: () => d_schema.Type_Node_Reference.tail.list.L.element;
+export declare namespace vp {
+    const d: () => d_schema.Value_Path.tail.l_list.L.l_item;
+    const g: (grp: string) => d_schema.Value_Path.tail.l_list.L.l_item;
+    const s: (state: string) => d_schema.Value_Path.tail.l_list.L.l_item;
+    const o: () => d_schema.Value_Path.tail.l_list.L.l_item;
 }
-export declare const sig_params: (values: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.values.dictionary.D.entry>, lookups: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.lookups.dictionary.D.entry>) => d_schema.Signature_Parameters;
+export declare const sig_params: (modules: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.modules.l_dictionary.D.l_entry>, lookups: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.lookups.l_dictionary.D.l_entry>) => d_schema.Signature_Parameters;
 /**
  * signature
  */
 export declare namespace sig {
-    const local: (values: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.values.dictionary.D.entry>, lookups: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.lookups.dictionary.D.entry>) => d_schema.Signatures.dictionary.D.entry;
-    const same_as: (name: string) => d_schema.Signatures.dictionary.D.entry;
+    const local: (modules: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.modules.l_dictionary.D.l_entry>, lookups: _p.Raw_Or_Normal_Dictionary<d_schema.Signature_Parameters.lookups.l_dictionary.D.l_entry>) => d_schema.Signatures.l_dictionary.D.l_entry;
+    const same_as: (name: string) => d_schema.Signatures.l_dictionary.D.l_entry;
 }
-export declare const value_parameter: (name: string, presence?: "optional" | "required") => d_schema.Signature_Parameters.values.dictionary.D.entry;
-export declare const value_parameter_external: (imp: string, type: string, presence?: "optional" | "required") => d_schema.Signature_Parameters.values.dictionary.D.entry;
-export declare const lookup_parameter: (name: string, type?: "acyclic" | "cyclic" | "stack", presence?: "optional" | "required") => d_schema.Signature_Parameters.lookups.dictionary.D.entry;
+export declare const value_parameter: (name: string, presence?: "optional" | "required") => d_schema.Signature_Parameters.modules.l_dictionary.D.l_entry;
+export declare const value_parameter_external: (imp: string, type: string, presence?: "optional" | "required") => d_schema.Signature_Parameters.modules.l_dictionary.D.l_entry;
+export declare const lookup_parameter: (name: string, type?: "acyclic" | "cyclic" | "stack", presence?: "optional" | "required") => d_schema.Signature_Parameters.lookups.l_dictionary.D.l_entry;
 /**
  * lookup selection
  */
 export declare namespace ls {
     const parameter: (parameter: string) => d_schema.Lookup_Selection;
-    const not_circular_dependent_siblings: () => d_schema.Lookup_Selection;
-    const possibly_circular_dependent_siblings: () => d_schema.Lookup_Selection;
+    namespace acyclic {
+        const siblings: () => d_schema.Lookup_Selection;
+        const resolved_dictionary: (value_selection: d_schema.Guaranteed_Value_Selection) => d_schema.Lookup_Selection;
+    }
+    namespace cyclic {
+        const siblings: () => d_schema.Lookup_Selection;
+    }
 }
 /**
  * node resolver lookup arguments
  */
 export declare namespace al {
-    const not_set: () => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
-    const empty_stack: () => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
-    /**
-     * creates a new stack of lookup selections from an existing stack and a new element
-     */
-    const stack: (stack: d_schema.Lookup_Selection, element: d_schema.Lookup_Selection) => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
-    /**
-     * provides a dictionary by selecting a value (that is guaranteed to be a dictionary)
-     */
-    const dictionary: (value_selection: d_schema.Guaranteed_Value_Selection) => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
+    namespace acyclic {
+        const not_set: () => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+        /**
+         * this one is only usable in the context of an ordered dictionary
+         */
+        const siblings: () => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+        const dictionary: (value_selection: d_schema.Guaranteed_Value_Selection) => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+    }
+    namespace cyclic {
+        /**
+         * this one is only usable in the context of a dictionary (ordered or not)
+         */
+        const siblings: () => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+        const not_set: () => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+    }
+    namespace stack {
+        const empty: () => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+        const push: (stack: d_schema.Lookup_Selection, item: d_schema.Lookup_Selection) => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
+    }
     /**
      * selects a lookup parameter of this resolver and passes it to the next resolver
      */
-    const parameter: (parameter: string) => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
-    /**
-     * this one is only usable in the context of an ordered dictionary
-     */
-    const not_circular_dependent_siblings: () => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
-    /**
-     * this one is only usable in the context of a dictionary (ordered or not)
-     */
-    const possibly_circular_dependent_siblings: () => d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry;
+    const parameter: (parameter: string) => d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry;
 }
 /**
  * value selection path step
  */
-export declare namespace vst {
-    const component: () => d_schema.Relative_Value_Selection.path.list.L.element;
-    const group: (property: string) => d_schema.Relative_Value_Selection.path.list.L.element;
-    const reference: () => d_schema.Relative_Value_Selection.path.list.L.element;
+export declare namespace rvs {
+    const component: () => d_schema.Relative_Value_Selection.path.l_list.L.l_item;
+    const group: (property: string) => d_schema.Relative_Value_Selection.path.l_list.L.l_item;
+    const reference: () => d_schema.Relative_Value_Selection.path.l_list.L.l_item;
 }
 /**
  * optional value initialization
@@ -125,77 +136,77 @@ export declare namespace ovi {
  * possible value selection
  */
 export declare namespace pvs {
-    const state_group: (state_group: string, result: d_schema.Type_Reference) => d_schema.Possible_Value_Selection;
-    const optional_value: (optional_value: string, result: d_schema.Type_Reference) => d_schema.Possible_Value_Selection;
+    const state: (state: string, result: d_schema.Module_Reference) => d_schema.Possible_Value_Selection;
+    const optional_value: (optional_value: string, result: d_schema.Module_Reference) => d_schema.Possible_Value_Selection;
     const parameter: (parameter: string) => d_schema.Possible_Value_Selection;
 }
 /**
  * guaranteed value selection
  */
 export declare namespace gvs {
-    const dictionary: (value_selection: d_schema.Guaranteed_Value_Selection) => d_schema.Lookup_Selection;
-    const component: (component: string, constraint: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const reference: (reference: string, constraint: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const list: (list: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const state_group: (state_group: string, result: d_schema.Type_Reference, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const optional_value: (optional_value: string, result: d_schema.Type_Reference, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const parameter: (parameter: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const list_cursor: (tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const linked_entry: (tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const sibling: (sibling: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const parent_sibling: (parent_sibling: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
-    const option_constraint: (constraint: string, tail: d_schema.Relative_Value_Selection.path.list.L.element[]) => d_schema.Guaranteed_Value_Selection;
+    const component: (component: string, constraint: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const reference: (reference: string, constraint: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const list: (list: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const state: (state: string, result: d_schema.Module_Reference, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const optional_value: (optional_value: string, result: d_schema.Module_Reference, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const parameter: (parameter: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const list_cursor: (tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const linked_entry: (tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const sibling: (sibling: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const parent_sibling: (parent_sibling: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
+    const option_constraint: (constraint: string, tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[]) => d_schema.Guaranteed_Value_Selection;
 }
 /**
  * node resolver value argument
  */
 export declare namespace av {
-    const parameter: (parameter: string) => d_schema.Node_Resolver.state_group.component._arguments.O.values.O.dictionary.D.entry;
-    const required: (value: d_schema.Guaranteed_Value_Selection) => d_schema.Node_Resolver.state_group.component._arguments.O.values.O.dictionary.D.entry;
-    const optional: (value: d_schema.Optional_Value_Initialization) => d_schema.Node_Resolver.state_group.component._arguments.O.values.O.dictionary.D.entry;
+    const parameter: (parameter: string) => d_schema.Value_Resolver.l_state.component.arguments_.O.modules.O.l_dictionary.D.l_entry;
+    const required: (value: d_schema.Guaranteed_Value_Selection) => d_schema.Value_Resolver.l_state.component.arguments_.O.modules.O.l_dictionary.D.l_entry;
+    const optional: (value: d_schema.Optional_Value_Initialization) => d_schema.Value_Resolver.l_state.component.arguments_.O.modules.O.l_dictionary.D.l_entry;
 }
-export declare const state: (resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver.state_group.state_group.states.dictionary.D.entry;
-export declare const state_constrained: (constraints: _p.Raw_Or_Normal_Dictionary<d_schema.Option_Constraints.dictionary.D.entry>, resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver.state_group.state_group.states.dictionary.D.entry;
+export declare const option: (resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver.l_state.state.states.l_dictionary.D.l_entry;
+export declare const option_constrained: (constraints: _p.Raw_Or_Normal_Dictionary<d_schema.Option_Constraint_Resolvers.l_dictionary.D.l_entry>, resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver.l_state.state.states.l_dictionary.D.l_entry;
 /**
  * option constraint
  */
 export declare namespace oc {
-    const state: (value_selection: d_schema.Guaranteed_Value_Selection, state: string) => d_schema.Option_Constraints.dictionary.D.entry;
-    const assert_set: (possibly_optional: d_schema.Possible_Value_Selection) => d_schema.Option_Constraints.dictionary.D.entry;
+    const state: (value_selection: d_schema.Guaranteed_Value_Selection, state: string) => d_schema.Option_Constraint_Resolvers.l_dictionary.D.l_entry;
+    const assert_set: (possibly_optional: d_schema.Possible_Value_Selection) => d_schema.Option_Constraint_Resolvers.l_dictionary.D.l_entry;
 }
 /**
  * property constraint
  */
 export declare namespace pc {
-    const property: (value_selection_tail: d_schema.Relative_Value_Selection.path.list.L.element[], state: string) => d_schema.Property_Constraints.dictionary.D.entry;
-    const constraint: (constraint: string, value_selection_tail: d_schema.Relative_Value_Selection.path.list.L.element[], state?: string) => d_schema.Property_Constraints.dictionary.D.entry;
+    const property: (value_selection_tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[], state: string) => d_schema.Value_Constraint_Resolvers.l_dictionary.D.l_entry;
+    const constraint: (constraint: string, value_selection_tail: d_schema.Relative_Value_Selection.path.l_list.L.l_item[], state?: string) => d_schema.Value_Constraint_Resolvers.l_dictionary.D.l_entry;
 }
 /**
  * node resolver
  */
 export declare namespace r {
-    const text: () => d_schema.Node_Resolver;
-    const boolean: () => d_schema.Node_Resolver;
-    const number: () => d_schema.Node_Resolver;
-    const component: (type: string, values: null | _p.Raw_Or_Normal_Dictionary<d_schema.Node_Resolver.state_group.component._arguments.O.values.O.dictionary.D.entry>, lookups: null | _p.Raw_Or_Normal_Dictionary<d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry>, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Property_Constraints.dictionary.D.entry>) => d_schema.Node_Resolver;
-    const component_external: (imp: string, type: string, values: null | _p.Raw_Or_Normal_Dictionary<d_schema.Node_Resolver.state_group.component._arguments.O.values.O.dictionary.D.entry>, lookups: null | _p.Raw_Or_Normal_Dictionary<d_schema.Node_Resolver.state_group.component._arguments.O.lookups.O.dictionary.D.entry>, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Property_Constraints.dictionary.D.entry>) => d_schema.Node_Resolver;
-    const dictionary: (resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver;
-    const dictionary_linked: (dense: "dense" | "sparse", selection: d_schema.Guaranteed_Value_Selection, resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver;
-    const group: (properties: _p.Raw_Or_Normal_Dictionary<d_schema.Node_Resolver_Group.dictionary.D.entry.resolver>) => d_schema.Node_Resolver;
-    const list: (type_resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver;
-    const list_with_result: (type_resolver: d_schema.Node_Resolver, result: d_schema.Type_Reference) => d_schema.Node_Resolver;
-    const nothing: () => d_schema.Node_Resolver;
-    const optional: (type_resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver;
-    const optional_constrained: (constraints: _p.Raw_Or_Normal_Dictionary<d_schema.Option_Constraints.dictionary.D.entry>, type_resolver: d_schema.Node_Resolver) => d_schema.Node_Resolver;
-    const reference_derived: (value_selection: d_schema.Guaranteed_Value_Selection) => d_schema.Node_Resolver;
-    const reference: (lookup_selection: d_schema.Lookup_Selection, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Property_Constraints.dictionary.D.entry>) => d_schema.Node_Resolver;
-    const reference_stack: (lookup_selection: d_schema.Lookup_Selection, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Property_Constraints.dictionary.D.entry>) => d_schema.Node_Resolver;
-    const state_group: (states: _p.Raw_Or_Normal_Dictionary<d_schema.Node_Resolver.state_group.state_group.states.dictionary.D.entry>) => d_schema.Node_Resolver;
+    const text: () => d_schema.Value_Resolver;
+    const boolean: () => d_schema.Value_Resolver;
+    const number: () => d_schema.Value_Resolver;
+    const component: (type: string, modules: null | _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.component.arguments_.O.modules.O.l_dictionary.D.l_entry>, lookups: null | _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry>) => d_schema.Value_Resolver;
+    const component_constrained: (type: string, modules: null | _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.component.arguments_.O.modules.O.l_dictionary.D.l_entry>, lookups: null | _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry>, constraints: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Constraint_Resolvers.l_dictionary.D.l_entry>) => d_schema.Value_Resolver;
+    const component_external: (imp: string, type: string, modules: null | _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.component.arguments_.O.modules.O.l_dictionary.D.l_entry>, lookups: null | _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.component.arguments_.O.lookups.O.l_dictionary.D.l_entry>, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Constraint_Resolvers.l_dictionary.D.l_entry>) => d_schema.Value_Resolver;
+    const dictionary: (resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver;
+    const dictionary_linked: (dense: "dense" | "sparse", selection: d_schema.Guaranteed_Value_Selection, resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver;
+    const group: (properties: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver_Group.l_dictionary.D.l_entry.resolver>) => d_schema.Value_Resolver;
+    const list: (type_resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver;
+    const list_with_result: (type_resolver: d_schema.Value_Resolver, result: d_schema.Module_Reference) => d_schema.Value_Resolver;
+    const nothing: () => d_schema.Value_Resolver;
+    const optional: (type_resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver;
+    const optional_constrained: (constraints: _p.Raw_Or_Normal_Dictionary<d_schema.Option_Constraint_Resolvers.l_dictionary.D.l_entry>, type_resolver: d_schema.Value_Resolver) => d_schema.Value_Resolver;
+    const reference_derived: (value_selection: d_schema.Guaranteed_Value_Selection) => d_schema.Value_Resolver;
+    const reference: (lookup_selection: d_schema.Lookup_Selection, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Constraint_Resolvers.l_dictionary.D.l_entry>) => d_schema.Value_Resolver;
+    const reference_stack: (lookup_selection: d_schema.Lookup_Selection, constraints?: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Constraint_Resolvers.l_dictionary.D.l_entry>) => d_schema.Value_Resolver;
+    const state: (states: _p.Raw_Or_Normal_Dictionary<d_schema.Value_Resolver.l_state.state.states.l_dictionary.D.l_entry>) => d_schema.Value_Resolver;
 }
-export declare const resolver: (type_resolver: d_schema.Node_Resolver) => d_schema.Resolvers.dictionary.D.entry;
-export declare const signatures: (signatures: _p.Raw_Or_Normal_Dictionary<d_schema.Signatures.dictionary.D.entry>) => d_schema.Resolve_Logic.signatures;
-export declare const resolvers: (resolvers: _p.Raw_Or_Normal_Dictionary<d_schema.Resolvers.dictionary.D.entry>) => d_schema.Resolvers;
-export declare const import_: (name: string) => d_schema.Imports.dictionary.D.entry;
-export declare const constrained: (signatures: d_schema.Resolve_Logic.signatures, resolvers: d_schema.Resolvers) => d_schema.Schema.complexity.state_group.constrained;
-export declare const unconstrained: () => d_schema.Schema.complexity.state_group.unconstrained;
-export declare const schema_: (imports: _p.Raw_Or_Normal_Dictionary<d_schema.Imports.dictionary.D.entry>, globals: d_schema.Globals, types: d_schema.Types, resolve: null | d_schema.Schema.complexity.state_group.constrained) => d_schema.Schemas.dictionary.D.entry;
+export declare const resolver: (value_resolver: d_schema.Value_Resolver) => d_schema.Module_Resolvers.l_dictionary.D.l_entry;
+export declare const signatures: (signatures: _p.Raw_Or_Normal_Dictionary<d_schema.Signatures.l_dictionary.D.l_entry>) => d_schema.Resolve_Logic.signatures;
+export declare const resolvers: (resolvers: _p.Raw_Or_Normal_Dictionary<d_schema.Module_Resolvers.l_dictionary.D.l_entry>) => d_schema.Module_Resolvers;
+export declare const import_: (name: string) => d_schema.Imports.l_dictionary.D.l_entry;
+export declare const constrained: (signatures: d_schema.Resolve_Logic.signatures, resolvers: d_schema.Module_Resolvers) => d_schema.Schema.complexity.l_state.constrained;
+export declare const unconstrained: () => d_schema.Schema.complexity.l_state.unconstrained;
+export declare const schema_: (imports: _p.Raw_Or_Normal_Dictionary<d_schema.Imports.l_dictionary.D.l_entry>, globals: d_schema.Globals, modules: d_schema.Modules, resolve: null | d_schema.Schema.complexity.l_state.constrained) => d_schema.Schemas.l_dictionary.D.l_entry;