pareto-core 0.1.0

package/dist/__internals/async/asynchronous_collection_builder.d.ts

@@ -0,0 +1,12 @@
+import * as _pi from "../../interface";
+export type Asynchronous_Dictionary_Builder<Entry> = {
+    'add entry': (key: string, entry: Entry) => void;
+    'get dictionary': () => _pi.Dictionary<Entry>;
+};
+export declare const create_asynchronous_dictionary_builder: <Entry>() => Asynchronous_Dictionary_Builder<Entry>;
+export type Asynchronous_List_Builder<Item> = {
+    'add item': (item: Item) => void;
+    'add list': (list: _pi.List<Item>) => void;
+    'get list': () => _pi.List<Item>;
+};
+export declare const create_asynchronous_list_builder: <Item>() => Asynchronous_List_Builder<Item>;

package/dist/__internals/async/asynchronous_collection_builder.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_asynchronous_list_builder = exports.create_asynchronous_dictionary_builder = void 0;
+const dictionary_1 = require("../sync/expression/literals/dictionary");
+const list_1 = require("../sync/expression/literals/list");
+const create_asynchronous_dictionary_builder = () => {
+    const entries = {};
+    return {
+        'add entry': (key, entry) => {
+            entries[key] = entry;
+        },
+        'get dictionary': () => {
+            return (0, dictionary_1.$$)(entries);
+        },
+    };
+};
+exports.create_asynchronous_dictionary_builder = create_asynchronous_dictionary_builder;
+const create_asynchronous_list_builder = () => {
+    const items = [];
+    return {
+        'add item': (item) => {
+            items.push(item);
+        },
+        'add list': (list) => {
+            list.__for_each(($) => {
+                items.push($);
+            });
+        },
+        'get list': () => {
+            return (0, list_1.$$)(items);
+        },
+    };
+};
+exports.create_asynchronous_list_builder = create_asynchronous_list_builder;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXN5bmNocm9ub3VzX2NvbGxlY3Rpb25fYnVpbGRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9fX2ludGVybmFscy9hc3luYy9hc3luY2hyb25vdXNfY29sbGVjdGlvbl9idWlsZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUNBLHVFQUFpRjtBQUNqRiwyREFBcUU7QUFPOUQsTUFBTSxzQ0FBc0MsR0FBRyxHQUFrRCxFQUFFO0lBQ3RHLE1BQU0sT0FBTyxHQUE2QixFQUFFLENBQUE7SUFFNUMsT0FBTztRQUNILFdBQVcsRUFBRSxDQUFDLEdBQVcsRUFBRSxLQUFZLEVBQUUsRUFBRTtZQUN2QyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsS0FBSyxDQUFBO1FBQ3hCLENBQUM7UUFFRCxnQkFBZ0IsRUFBRSxHQUFHLEVBQUU7WUFDbkIsT0FBTyxJQUFBLGVBQWtCLEVBQUMsT0FBTyxDQUFDLENBQUE7UUFDdEMsQ0FBQztLQUNKLENBQUE7QUFDTCxDQUFDLENBQUE7QUFaWSxRQUFBLHNDQUFzQywwQ0FZbEQ7QUFRTSxNQUFNLGdDQUFnQyxHQUFHLEdBQTBDLEVBQUU7SUFDeEYsTUFBTSxLQUFLLEdBQVcsRUFBRSxDQUFBO0lBRXhCLE9BQU87UUFDSCxVQUFVLEVBQUUsQ0FBQyxJQUFVLEVBQUUsRUFBRTtZQUN2QixLQUFLLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFBO1FBQ3BCLENBQUM7UUFDRCxVQUFVLEVBQUUsQ0FBQyxJQUFvQixFQUFFLEVBQUU7WUFDakMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFO2dCQUNsQixLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFBO1lBQ2pCLENBQUMsQ0FBQyxDQUFBO1FBQ04sQ0FBQztRQUVELFVBQVUsRUFBRSxHQUFHLEVBQUU7WUFDYixPQUFPLElBQUEsU0FBWSxFQUFDLEtBQUssQ0FBQyxDQUFBO1FBQzlCLENBQUM7S0FDSixDQUFBO0FBQ0wsQ0FBQyxDQUFBO0FBakJZLFFBQUEsZ0NBQWdDLG9DQWlCNUMifQ==

package/dist/__internals/async/create_asynchronous_processes_monitor.d.ts

@@ -0,0 +1,15 @@
+export type I_Async_Monitor = {
+    readonly 'report process started': () => void;
+    readonly 'report process finished': () => void;
+};
+/**
+ * this function helps in keeping track of ongoing async operations
+ * async operations are registered and when finished reported as such.
+ * when all ongoing operations are finished the onEnd callback is called
+ *
+ * this function is specifically useful for async map functions
+ *
+ * @param callback this callback creates a scope within which the counter is provided
+ * @param onEnd this callback will be called when all ongoing operations are finished
+ */
+export declare function create_asynchronous_processes_monitor(monitoring_phase: ($: I_Async_Monitor) => void, on_all_finished: () => void): void;

package/dist/__internals/async/create_asynchronous_processes_monitor.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_asynchronous_processes_monitor = create_asynchronous_processes_monitor;
+/**
+ * this function helps in keeping track of ongoing async operations
+ * async operations are registered and when finished reported as such.
+ * when all ongoing operations are finished the onEnd callback is called
+ *
+ * this function is specifically useful for async map functions
+ *
+ * @param callback this callback creates a scope within which the counter is provided
+ * @param onEnd this callback will be called when all ongoing operations are finished
+ */
+function create_asynchronous_processes_monitor(monitoring_phase, on_all_finished) {
+    let counter = 0;
+    /*
+     * we need to keep track of if the registration phase is ended or not.
+     * it can happen that the counter reaches 0 during the registration phase, specifically if there is no real async calls being made
+     * in that case the reportFinished counter is als called during the registration phase.
+     * If that happens there should not yet be a call to onEnd().
+     */
+    let registration_phase_ended = false;
+    let on_all_finished_has_been_called = false;
+    function checkStatus() {
+        if (registration_phase_ended) {
+            if (counter === 0) {
+                if (on_all_finished_has_been_called === true) {
+                    throw new Error("CORE: already ended");
+                }
+                on_all_finished_has_been_called = true;
+                on_all_finished();
+            }
+        }
+    }
+    monitoring_phase({
+        'report process started': () => {
+            if (on_all_finished_has_been_called) {
+                throw new Error("CORE: async call done after context is ready");
+            }
+            counter += 1;
+        },
+        'report process finished': () => {
+            if (counter === 0) {
+                throw new Error("CORE: decrement while counter is 0");
+            }
+            counter -= 1;
+            checkStatus();
+        },
+    });
+    registration_phase_ended = true;
+    checkStatus();
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX2FzeW5jaHJvbm91c19wcm9jZXNzZXNfbW9uaXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9fX2ludGVybmFscy9hc3luYy9jcmVhdGVfYXN5bmNocm9ub3VzX3Byb2Nlc3Nlc19tb25pdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBZ0JBLHNGQThDQztBQXhERDs7Ozs7Ozs7O0dBU0c7QUFDSCxTQUFnQixxQ0FBcUMsQ0FDakQsZ0JBQThDLEVBQzlDLGVBQTJCO0lBRzNCLElBQUksT0FBTyxHQUFHLENBQUMsQ0FBQTtJQUVmOzs7OztPQUtHO0lBQ0gsSUFBSSx3QkFBd0IsR0FBRyxLQUFLLENBQUE7SUFDcEMsSUFBSSwrQkFBK0IsR0FBRyxLQUFLLENBQUE7SUFFM0MsU0FBUyxXQUFXO1FBQ2hCLElBQUksd0JBQXdCLEVBQUUsQ0FBQztZQUUzQixJQUFJLE9BQU8sS0FBSyxDQUFDLEVBQUUsQ0FBQztnQkFDaEIsSUFBSSwrQkFBK0IsS0FBSyxJQUFJLEVBQUUsQ0FBQztvQkFDM0MsTUFBTSxJQUFJLEtBQUssQ0FBQyxxQkFBcUIsQ0FBQyxDQUFBO2dCQUMxQyxDQUFDO2dCQUNELCtCQUErQixHQUFHLElBQUksQ0FBQTtnQkFDdEMsZUFBZSxFQUFFLENBQUE7WUFDckIsQ0FBQztRQUNMLENBQUM7SUFDTCxDQUFDO0lBQ0QsZ0JBQWdCLENBQUM7UUFDYix3QkFBd0IsRUFBRSxHQUFHLEVBQUU7WUFDM0IsSUFBSSwrQkFBK0IsRUFBRSxDQUFDO2dCQUNsQyxNQUFNLElBQUksS0FBSyxDQUFDLDhDQUE4QyxDQUFDLENBQUE7WUFDbkUsQ0FBQztZQUNELE9BQU8sSUFBSSxDQUFDLENBQUE7UUFFaEIsQ0FBQztRQUNELHlCQUF5QixFQUFFLEdBQUcsRUFBRTtZQUM1QixJQUFJLE9BQU8sS0FBSyxDQUFDLEVBQUUsQ0FBQztnQkFDaEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxvQ0FBb0MsQ0FBQyxDQUFBO1lBQ3pELENBQUM7WUFDRCxPQUFPLElBQUksQ0FBQyxDQUFBO1lBQ1osV0FBVyxFQUFFLENBQUE7UUFDakIsQ0FBQztLQUNKLENBQUMsQ0FBQTtJQUNGLHdCQUF3QixHQUFHLElBQUksQ0FBQTtJQUMvQixXQUFXLEVBQUUsQ0FBQTtBQUNqQixDQUFDIn0=

package/dist/__internals/async/create_refinement_context.d.ts

@@ -0,0 +1,5 @@
+import * as _pi from "../../interface";
+export type Refinement_Result<Output, Error> = {
+    __extract_data: (on_success: ($: Output) => void, on_error: ($: Error) => void) => void;
+};
+export declare const create_refinement_context: <Output, Error>(callback: (abort: _pi.Abort<Error>) => Output) => Refinement_Result<Output, Error>;

package/dist/__internals/async/create_refinement_context.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.create_refinement_context = void 0;
+const create_refinement_context = (callback) => {
+    return ({
+        __extract_data(on_result, on_error) {
+            class Refine_Guard_Abort_Error {
+                constructor(error) {
+                    this.error = error;
+                }
+            }
+            try {
+                on_result(callback((error) => {
+                    throw new Refine_Guard_Abort_Error(error);
+                }));
+            }
+            catch (e) {
+                if (e instanceof Refine_Guard_Abort_Error) {
+                    on_error(e.error);
+                }
+                else {
+                    throw e; // re-throw unexpected errors
+                }
+            }
+        }
+    });
+};
+exports.create_refinement_context = create_refinement_context;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlX3JlZmluZW1lbnRfY29udGV4dC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9fX2ludGVybmFscy9hc3luYy9jcmVhdGVfcmVmaW5lbWVudF9jb250ZXh0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQVlPLE1BQU0seUJBQXlCLEdBQUcsQ0FDckMsUUFBNkMsRUFDYixFQUFFO0lBQ2xDLE9BQU8sQ0FBQztRQUNKLGNBQWMsQ0FDVixTQUE4QixFQUM5QixRQUE0QjtZQUU1QixNQUFNLHdCQUF3QjtnQkFDMUIsWUFDb0IsS0FBWTtvQkFBWixVQUFLLEdBQUwsS0FBSyxDQUFPO2dCQUM1QixDQUFDO2FBQ1I7WUFDRCxJQUFJLENBQUM7Z0JBQ0QsU0FBUyxDQUNMLFFBQVEsQ0FDSixDQUFDLEtBQUssRUFBRSxFQUFFO29CQUNOLE1BQU0sSUFBSSx3QkFBd0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztnQkFDOUMsQ0FBQyxDQUNKLENBQ0osQ0FBQTtZQUNMLENBQUM7WUFBQyxPQUFPLENBQUMsRUFBRSxDQUFDO2dCQUNULElBQUksQ0FBQyxZQUFZLHdCQUF3QixFQUFFLENBQUM7b0JBQ3hDLFFBQVEsQ0FBQyxDQUFDLENBQUMsS0FBSyxDQUFDLENBQUE7Z0JBQ3JCLENBQUM7cUJBQU0sQ0FBQztvQkFDSixNQUFNLENBQUMsQ0FBQSxDQUFDLDZCQUE2QjtnQkFDekMsQ0FBQztZQUNMLENBQUM7UUFDTCxDQUFDO0tBQ0osQ0FBQyxDQUFBO0FBQ04sQ0FBQyxDQUFBO0FBOUJZLFFBQUEseUJBQXlCLDZCQThCckMifQ==

package/dist/__internals/sync/expression/decide/index.d.ts

@@ -0,0 +1,6 @@
+import { $$ as state_group_assert_unreachable } from "./state_group/assert_unreachable";
+import { $$ as state_group_switch_state } from "./state_group/switch_state";
+import { $$ as state_group_select } from "./state_group/select";
+export declare const au: typeof state_group_assert_unreachable;
+export declare const ss: typeof state_group_switch_state;
+export declare const sg: typeof state_group_select;

package/dist/__internals/sync/expression/decide/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sg = exports.ss = exports.au = void 0;
+const assert_unreachable_1 = require("./state_group/assert_unreachable");
+const switch_state_1 = require("./state_group/switch_state");
+const select_1 = require("./state_group/select");
+exports.au = assert_unreachable_1.$$;
+exports.ss = switch_state_1.$$;
+exports.sg = select_1.$$;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvX19pbnRlcm5hbHMvc3luYy9leHByZXNzaW9uL2RlY2lkZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSx5RUFBdUY7QUFDdkYsNkRBQTJFO0FBQzNFLGlEQUErRDtBQUVsRCxRQUFBLEVBQUUsR0FBRyx1QkFBOEIsQ0FBQTtBQUNuQyxRQUFBLEVBQUUsR0FBRyxpQkFBd0IsQ0FBQTtBQUM3QixRQUFBLEVBQUUsR0FBRyxXQUFrQixDQUFBIn0=

package/dist/__internals/sync/expression/decide/state_group/assert_unreachable.d.ts

@@ -0,0 +1,15 @@
+/**
+ * au means 'assert unreachable'. Used in the 'default' clause of switch statements to ensure
+ * during compile time that all possible cases have been implemented
+ *
+ * example:
+ *
+ * switch (x) {
+ *     case "5":
+ *         break
+ *     default: au(x)
+ * }
+ *
+ * @param _x
+ */
+export declare function $$<RT>(_x: never): RT;

package/dist/__internals/sync/expression/decide/state_group/assert_unreachable.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$ = $$;
+/**
+ * au means 'assert unreachable'. Used in the 'default' clause of switch statements to ensure
+ * during compile time that all possible cases have been implemented
+ *
+ * example:
+ *
+ * switch (x) {
+ *     case "5":
+ *         break
+ *     default: au(x)
+ * }
+ *
+ * @param _x
+ */
+function $$(_x) {
+    throw new Error("unreachable");
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXNzZXJ0X3VucmVhY2hhYmxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL19faW50ZXJuYWxzL3N5bmMvZXhwcmVzc2lvbi9kZWNpZGUvc3RhdGVfZ3JvdXAvYXNzZXJ0X3VucmVhY2hhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBZUMsZ0JBRUE7QUFoQkQ7Ozs7Ozs7Ozs7Ozs7R0FhRztBQUNGLFNBQWdCLEVBQUUsQ0FBSyxFQUFTO0lBQzdCLE1BQU0sSUFBSSxLQUFLLENBQUMsYUFBYSxDQUFDLENBQUE7QUFDbEMsQ0FBQyJ9

package/dist/__internals/sync/expression/decide/state_group/select.d.ts

@@ -0,0 +1,15 @@
+/**
+ * cc means 'change context'. It creates a new scope in which a variable name can be used again
+ * (usually '$', a variable name that indicates the current context in exupery)
+ *
+ * example:
+ *
+ * cc($[1], ($) => {
+ *     //here $[1] has become $
+ * })
+ *
+ * @param input
+ * @param callback
+ * @returns
+ */
+export declare function $$<T extends readonly [string, any], RT>(input: T, callback: (output: T) => RT): RT;

package/dist/__internals/sync/expression/decide/state_group/select.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * cc means 'change context'. It creates a new scope in which a variable name can be used again
+ * (usually '$', a variable name that indicates the current context in exupery)
+ *
+ * example:
+ *
+ * cc($[1], ($) => {
+ *     //here $[1] has become $
+ * })
+ *
+ * @param input
+ * @param callback
+ * @returns
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$ = $$;
+function $$(input, callback) {
+    return callback(input);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VsZWN0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL19faW50ZXJuYWxzL3N5bmMvZXhwcmVzc2lvbi9kZWNpZGUvc3RhdGVfZ3JvdXAvc2VsZWN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7OztHQWFHOztBQUVILGdCQUVDO0FBRkQsU0FBZ0IsRUFBRSxDQUF1QyxLQUFRLEVBQUUsUUFBMkI7SUFDMUYsT0FBTyxRQUFRLENBQUMsS0FBSyxDQUFDLENBQUE7QUFDMUIsQ0FBQyJ9

package/dist/__internals/sync/expression/decide/state_group/switch_state.d.ts

@@ -0,0 +1,19 @@
+export type State<T> = readonly [string | boolean, T];
+/**
+ * ss means 'switch state'.
+ * used to make the value T the context variable ('$')
+ * given a tuple of a string (or boolean) and a value T,
+ * the function takes the value T and calls back the callback ($c)
+ * notice that the string part is never used
+ *
+ * example:
+ *
+ * switch ($.state[0]) {
+ *     case "on":
+ *          return ss($.state, ($) => $.value
+ *     case "off":
+ *          return ss($.state, ($) => null
+ *     default: au($.state[0])
+ * }
+ */
+export declare function $$<T, RT>($: State<T>, $c: ($: T) => RT): RT;

package/dist/__internals/sync/expression/decide/state_group/switch_state.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.$$ = $$;
+/**
+ * ss means 'switch state'.
+ * used to make the value T the context variable ('$')
+ * given a tuple of a string (or boolean) and a value T,
+ * the function takes the value T and calls back the callback ($c)
+ * notice that the string part is never used
+ *
+ * example:
+ *
+ * switch ($.state[0]) {
+ *     case "on":
+ *          return ss($.state, ($) => $.value
+ *     case "off":
+ *          return ss($.state, ($) => null
+ *     default: au($.state[0])
+ * }
+ */
+function $$($, $c) {
+    return $c($[1]);
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3dpdGNoX3N0YXRlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL19faW50ZXJuYWxzL3N5bmMvZXhwcmVzc2lvbi9kZWNpZGUvc3RhdGVfZ3JvdXAvc3dpdGNoX3N0YXRlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBcUJBLGdCQUtDO0FBdEJEOzs7Ozs7Ozs7Ozs7Ozs7O0dBZ0JHO0FBQ0gsU0FBZ0IsRUFBRSxDQUNkLENBQVcsRUFDWCxFQUFnQjtJQUVoQixPQUFPLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQTtBQUNuQixDQUFDIn0=

package/dist/__internals/sync/expression/initialize.d.ts

@@ -0,0 +1,66 @@
+import * as _pi from "../../../interface";
+import { $$ as dictionary_literal } from "./literals/dictionary";
+import { $$ as list_literal } from "./literals/list";
+import { set as optional_set, not_set as optional_not_set } from "./literals/optional";
+export declare namespace boolean {
+    const dictionary_is_empty: <T>($: _pi.Dictionary<T>) => boolean;
+    const list_is_empty: <T>($: _pi.List<T>) => boolean;
+}
+export declare namespace dictionary {
+    const filter: <T, New_Type>($: _pi.Dictionary<T>, handle_value: (value: T, id: string) => _pi.Optional_Value<New_Type>) => _pi.Dictionary<New_Type>;
+    const from_list: <T, NT>(list: _pi.List<T>, get_key: (item: T) => string, get_value: (item: T) => NT, abort: _pi.Abort<["duplicate id in list to dictionary", null]>) => _pi.Dictionary<NT>;
+    const group_dictionary: <T>(dictionary: _pi.Dictionary<T>, get_key: (item: T, id: string) => string) => _pi.Dictionary<_pi.Dictionary<T>>;
+    const group_list: <T>(list: _pi.List<T>, get_key: (item: T) => string) => _pi.Dictionary<_pi.List<T>>;
+    const literal: typeof dictionary_literal;
+    const map: <T, New_Type>($: _pi.Dictionary<T>, handle_value: (value: T, id: string) => New_Type) => _pi.Dictionary<New_Type>;
+    const resolve: <Unresolved, Resolved>(source: _pi.Dictionary<Unresolved>, handle_entry: ($: Unresolved, key: string, acyclic_lookup: _pi.Acyclic_Lookup<Resolved>, cyclic_lookup: _pi.Cyclic_Lookup<Resolved>) => Resolved) => _pi.Dictionary<Resolved>;
+}
+export declare namespace integer {
+    /**
+     * Performs integer division of two numbers (rounding towards negative infinity).
+     *
+     * dividend / divisor
+     *
+     * examples:
+     * integer_division(7, 3) === 2
+     * integer_division(7, -3) === -3
+     * integer_division(-7, 3) === -3
+     * integer_division(-7, -3) === 2
+     */
+    const divide: (dividend: number, divisor: number, abort: _pi.Abort<["divide by zero", null]>) => number;
+}
+export declare namespace list {
+    type List_Builder<T> = {
+        'add element': ($: T) => void;
+        'add list': ($: _pi.List<T>) => void;
+    };
+    export const deprecated_build: <T>($: ($c: List_Builder<T>) => void) => _pi.List<T>;
+    export const filter: <T, New_Type>($: _pi.List<T>, handle_value: (value: T) => _pi.Optional_Value<New_Type>) => _pi.List<New_Type>;
+    export const flatten: <T, NT>(lists: (_pi.List<T>), callback: ($: T) => _pi.List<NT>) => _pi.List<NT>;
+    export const from_dictionary: <T, New_Type>($: _pi.Dictionary<T>, handle_entry: ($: T, id: string) => New_Type) => _pi.List<New_Type>;
+    export const from_single: <T>($: T) => _pi.List<T>;
+    export const literal: typeof list_literal;
+    export type NonUndefined = null | {};
+    export const nested_literal_old: <T extends NonUndefined | {}>(lists: (undefined | T[] | _pi.List<T>)[]) => _pi.List<T>;
+    export type Nested<T> = undefined | Nested<T>[] | _pi.List<T>;
+    export const nested_literal_new: <T extends NonUndefined | {}>(nested: Nested<T>) => _pi.List<T>;
+    export const map: <T, New_Type>($: _pi.List<T>, handle_value: (value: T) => New_Type) => _pi.List<New_Type>;
+    export const map_with_state: <T, New_Type, State>($: _pi.List<T>, initial_state: State, handle_value: (value: T, state: State) => New_Type, update_state: (value: T, state: State) => State) => _pi.List<New_Type>;
+    export const reverse: <T>($: _pi.List<T>) => _pi.List<T>;
+    export {};
+}
+export declare namespace natural {
+    const amount_of_dictionary_entries: <T>(dictionary: _pi.Dictionary<T>) => number;
+    const amount_of_list_elements: <T>(list: _pi.List<T>) => number;
+    const source_column: (depth: number) => number;
+    const source_line: (depth: number) => number;
+    const text_length: ($: string) => number;
+}
+export declare namespace optional {
+    function block<RT>(callback: () => _pi.Optional_Value<RT>): _pi.Optional_Value<RT>;
+    const set: typeof optional_set;
+    const not_set: typeof optional_not_set;
+}
+export declare namespace state_group {
+    function block<RT extends readonly [string, any]>(callback: () => RT): RT;
+}