pareto-liana 0.0.0

package/dist/modules/pareto-fountain-pen-directory/implementation/manual/schemas/path/transformers/path.js

@@ -0,0 +1,53 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replace_space_in_context_path = void 0;
+const _pds = __importStar(require("pareto-core-deserializer"));
+const replace = ($, search, replace) => {
+    return _pds.text.deprecated_build(($i) => {
+        _pds.list.from_text($, ($) => $).__for_each(($) => {
+            if ($ === search) {
+                $i['add character'](replace);
+            }
+            else {
+                $i['add character']($);
+            }
+        });
+    });
+};
+const replace_space_in_context_path = ($) => {
+    const replace_space = ($) => {
+        return replace($, 32, 95 /* space -> underscore */);
+    };
+    return {
+        'context': {
+            'start': $.context.start,
+            'subpath': $.context.subpath.__l_map(($) => replace_space($)),
+        },
+        'node': replace_space($.node)
+    };
+};
+exports.replace_space_in_context_path = replace_space_in_context_path;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGF0aC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tb2R1bGVzL3BhcmV0by1mb3VudGFpbi1wZW4tZGlyZWN0b3J5L2ltcGxlbWVudGF0aW9uL21hbnVhbC9zY2hlbWFzL3BhdGgvdHJhbnNmb3JtZXJzL3BhdGgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFDQSwrREFBZ0Q7QUFLaEQsTUFBTSxPQUFPLEdBQUcsQ0FBQyxDQUFTLEVBQUUsTUFBYyxFQUFFLE9BQWUsRUFBVSxFQUFFO0lBQ25FLE9BQU8sSUFBSSxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLEVBQUUsRUFBRSxFQUFFO1FBQ3JDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxFQUFFLEVBQUU7WUFDOUMsSUFBSSxDQUFDLEtBQUssTUFBTSxFQUFFLENBQUM7Z0JBQ2YsRUFBRSxDQUFDLGVBQWUsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFBO1lBQ2hDLENBQUM7aUJBQU0sQ0FBQztnQkFDSixFQUFFLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUE7WUFDMUIsQ0FBQztRQUNMLENBQUMsQ0FBQyxDQUFBO0lBQ04sQ0FBQyxDQUFDLENBQUE7QUFDTixDQUFDLENBQUE7QUFFTSxNQUFNLDZCQUE2QixHQUFHLENBQUMsQ0FBbUIsRUFBb0IsRUFBRTtJQUNuRixNQUFNLGFBQWEsR0FBRyxDQUFDLENBQVMsRUFBVSxFQUFFO1FBQ3hDLE9BQU8sT0FBTyxDQUFDLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLHlCQUF5QixDQUFDLENBQUE7SUFDdkQsQ0FBQyxDQUFBO0lBQ0QsT0FBTztRQUNILFNBQVMsRUFBRTtZQUNQLE9BQU8sRUFBRSxDQUFDLENBQUMsT0FBTyxDQUFDLEtBQUs7WUFDeEIsU0FBUyxFQUFFLENBQUMsQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsYUFBYSxDQUFDLENBQUMsQ0FBQyxDQUFDO1NBQ2hFO1FBQ0QsTUFBTSxFQUFFLGFBQWEsQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDO0tBQ2hDLENBQUE7QUFDTCxDQUFDLENBQUE7QUFYWSxRQUFBLDZCQUE2QixpQ0FXekMifQ==

package/dist/modules/pareto-fountain-pen-directory/interface/resources.d.ts

@@ -0,0 +1,11 @@
+import * as _pi from 'pareto-core-interface';
+import * as d_console_error from "./to_be_generated/console_error";
+import * as d_console_log from "./to_be_generated/console_log";
+import * as d_write_to_directory from "./to_be_generated/write_to_dictionary";
+import * as d_write_to_file from "./to_be_generated/write_to_file";
+export declare namespace commands {
+    type console_error = _pi.Command<d_console_error.Error, d_console_error.Parameters>;
+    type console_log = _pi.Command<d_console_log.Error, d_console_log.Parameters>;
+    type write_to_directory = _pi.Command<d_write_to_directory.Error, d_write_to_directory.Parameters>;
+    type write_to_file = _pi.Command<d_write_to_file.Error, d_write_to_file.Parameters>;
+}

package/dist/modules/pareto-fountain-pen-directory/interface/resources.js

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

package/dist/modules/pareto-fountain-pen-directory/interface/signatures.d.ts

@@ -0,0 +1,19 @@
+import * as _pi from 'pareto-core-interface';
+import * as resources from "./resources";
+import * as resources_exupery from "pareto-resources/dist/interface/resources";
+export declare namespace commands {
+    type console_error = _pi.Command_Procedure<resources.commands.console_error, {
+        'log error': resources_exupery.commands.log_error;
+    }, null>;
+    type console_log = _pi.Command_Procedure<resources.commands.console_log, {
+        'log': resources_exupery.commands.log;
+    }, null>;
+    type write_to_directory = _pi.Command_Procedure<resources.commands.write_to_directory, {
+        'remove': resources_exupery.commands.remove;
+        'write to_file': resources.commands.write_to_file;
+    }, null>;
+    type write_to_file = _pi.Command_Procedure<resources.commands.write_to_file, {
+        'make directory': resources_exupery.commands.make_directory;
+        'write file': resources_exupery.commands.write_file;
+    }, null>;
+}

package/dist/modules/pareto-fountain-pen-directory/interface/signatures.js

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

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/console_error.d.ts

@@ -0,0 +1,6 @@
+import * as d_fp_block from "pareto-fountain-pen/dist/interface/generated/pareto/schemas/block/data";
+export type Error = null;
+export type Parameters = {
+    'group': d_fp_block.Group;
+    'indentation': string;
+};

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/console_error.js

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

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/console_log.d.ts

@@ -0,0 +1,6 @@
+import * as d_fp_block from "pareto-fountain-pen/dist/interface/generated/pareto/schemas/block/data";
+export type Error = null;
+export type Parameters = {
+    'group': d_fp_block.Group;
+    'indentation': string;
+};

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/console_log.js

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

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/write_to_dictionary.d.ts

@@ -0,0 +1,15 @@
+import * as _pi from 'pareto-core-interface';
+import * as d_remove from "pareto-resources/dist/interface/generated/pareto/schemas/remove/data";
+import * as d_fp_block from "pareto-fountain-pen/dist/interface/generated/pareto/schemas/block/data";
+import * as d_path from "pareto-resources/dist/interface/generated/pareto/schemas/path/data";
+import * as d_write_to_file from "./write_to_file";
+export type Error = ['remove', d_remove.Error] | ['nodes', _pi.Dictionary<Error__nodes>];
+export type Error__nodes = ['directory', Error] | ['file', d_write_to_file.Error];
+export type Parameters = {
+    'escape spaces in path': boolean;
+    'path': d_path.Node_Path;
+    'directory': d_fp_block.Directory;
+    'indentation': string;
+    'newline': string;
+    'remove before creating': boolean;
+};

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/write_to_dictionary.js

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

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/write_to_file.d.ts

@@ -0,0 +1,13 @@
+import * as d_write_file from "pareto-resources/dist/interface/generated/pareto/schemas/write_file/data";
+import * as d_make_directory from "pareto-resources/dist/interface/generated/pareto/schemas/make_directory/data";
+import * as d_fp_block from "pareto-fountain-pen/dist/interface/generated/pareto/schemas/block/data";
+import * as d_path from "pareto-resources/dist/interface/generated/pareto/schemas/path/data";
+export type Error = ['make directory', d_make_directory.Error] | ['write file', d_write_file.Error];
+export type Parameters = {
+    'escape spaces in path': boolean;
+    'group': d_fp_block.Group;
+    'directory path': d_path.Node_Path;
+    'filename': string;
+    'indentation': string;
+    'newline': string;
+};

package/dist/modules/pareto-fountain-pen-directory/interface/to_be_generated/write_to_file.js

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

package/dist/shorthands/module.d.ts

@@ -0,0 +1,7 @@
+import * as _p from 'pareto-core-shorthands/dist/unresolved_data';
+import * as unresolved from "../interface/generated/pareto/schemas/module/data/unresolved";
+import * as unresolved_schema from "../interface/generated/pareto/schemas/schema/data/unresolved";
+export declare const module_: (operations: unresolved.Operations, schema_tree: unresolved_schema.Schema_Tree) => unresolved.Module;
+export declare const operations: (operations: _p.Raw_Or_Normal_Dictionary<unresolved.Operations.dictionary.D.entry>) => unresolved.Operations;
+export declare const operation: (type_parameters: _p.Raw_Or_Normal_Dictionary<unresolved_schema.Type_Parameters.dictionary.D.entry>, context: unresolved.Operations.dictionary.D.entry.state_group.operation.context, parameters: _p.Raw_Or_Normal_Dictionary<unresolved.Operations.dictionary.D.entry.state_group.operation.parameters.dictionary.D.entry>, result: unresolved.Operations.dictionary.D.entry.state_group.operation.result) => unresolved.Operations.dictionary.D.entry;
+export declare const set: (operations: _p.Raw_Or_Normal_Dictionary<unresolved.Operations.dictionary.D.entry>) => unresolved.Operations.dictionary.D.entry;

package/dist/shorthands/module.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.set = exports.operation = exports.operations = exports.module_ = void 0;
+const _p = __importStar(require("pareto-core-shorthands/dist/unresolved_data"));
+const module_ = (operations, schema_tree) => ({
+    'operations': operations,
+    'schema tree': schema_tree,
+});
+exports.module_ = module_;
+const operations = (operations) => _p.wrap_dictionary(operations);
+exports.operations = operations;
+const operation = (type_parameters, context, parameters, result) => {
+    return _p.wrap_state_group(['operation', {
+            'type parameters': _p.wrap_dictionary(type_parameters),
+            'context': context,
+            'parameters': _p.wrap_dictionary(parameters),
+            'result': result
+        }]);
+};
+exports.operation = operation;
+const set = (operations) => {
+    return _p.wrap_state_group(['set', _p.wrap_dictionary(operations)]);
+};
+exports.set = set;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Nob3J0aGFuZHMvbW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsZ0ZBQWlFO0FBTzFELE1BQU0sT0FBTyxHQUFHLENBQ25CLFVBQWlDLEVBQ2pDLFdBQTBDLEVBQ3pCLEVBQUUsQ0FBQyxDQUFDO0lBQ3JCLFlBQVksRUFBRSxVQUFVO0lBQ3hCLGFBQWEsRUFBRSxXQUFXO0NBQzdCLENBQUMsQ0FBQTtBQU5XLFFBQUEsT0FBTyxXQU1sQjtBQUVLLE1BQU0sVUFBVSxHQUFHLENBQ3RCLFVBQWlGLEVBQzVELEVBQUUsQ0FBQyxFQUFFLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQyxDQUFBO0FBRjdDLFFBQUEsVUFBVSxjQUVtQztBQUVuRCxNQUFNLFNBQVMsR0FBRyxDQUNyQixlQUFrRyxFQUNsRyxPQUErRSxFQUMvRSxVQUFxSSxFQUNySSxNQUE2RSxFQUNyQyxFQUFFO0lBQzFDLE9BQU8sRUFBRSxDQUFDLGdCQUFnQixDQUFDLENBQUMsV0FBVyxFQUFFO1lBQ3JDLGlCQUFpQixFQUFFLEVBQUUsQ0FBQyxlQUFlLENBQUMsZUFBZSxDQUFDO1lBQ3RELFNBQVMsRUFBRSxPQUFPO1lBQ2xCLFlBQVksRUFBRSxFQUFFLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQztZQUM1QyxRQUFRLEVBQUUsTUFBTTtTQUNuQixDQUFDLENBQUMsQ0FBQTtBQUNQLENBQUMsQ0FBQTtBQVpZLFFBQUEsU0FBUyxhQVlyQjtBQUVNLE1BQU0sR0FBRyxHQUFHLENBQ2YsVUFBaUYsRUFDekMsRUFBRTtJQUMxQyxPQUFPLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDLEtBQUssRUFBRSxFQUFFLENBQUMsZUFBZSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUN2RSxDQUFDLENBQUE7QUFKWSxRQUFBLEdBQUcsT0FJZiJ9

package/dist/shorthands/schema.d.ts

@@ -0,0 +1,201 @@
+import * as _p from 'pareto-core-shorthands/dist/unresolved_data';
+import * as d_schema from "../interface/generated/pareto/schemas/schema/data/unresolved";
+/**
+ * schema tree
+ */
+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 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;
+/**
+ * number type
+ */
+export declare namespace n {
+    const integer: (decimal_separator_offset?: 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;
+}
+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;
+/**
+ * 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;
+}
+/**
+ * type node reference 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 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;
+/**
+ * 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;
+}
+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;
+/**
+ * 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;
+}
+/**
+ * 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;
+    /**
+     * 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;
+}
+/**
+ * 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;
+}
+/**
+ * optional value initialization
+ */
+export declare namespace ovi {
+    const not_set: () => d_schema.Optional_Value_Initialization;
+    const set: (value: d_schema.Guaranteed_Value_Selection) => d_schema.Optional_Value_Initialization;
+    const selection: (selection: d_schema.Possible_Value_Selection) => d_schema.Optional_Value_Initialization;
+}
+/**
+ * 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 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;
+}
+/**
+ * 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;
+}
+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;
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+/**
+ * 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;
+}
+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;