pareto-core 0.1.161 → 0.1.162

package/dist/implementation/__internal/sync/production.d.ts

@@ -0,0 +1,10 @@
+import * as p_di from "../../../interface/data";
+export declare const boolean: (boolean_value: boolean) => {};
+export declare const dictionary: <T extends p_di.Value>(dictionary: p_di.Dictionary<T>) => {};
+export declare const list: <T extends p_di.Value>(list: p_di.List<T>) => {};
+export declare namespace number {
+}
+export declare const number: (number: number) => {};
+export declare const optional: <T extends p_di.Value>(optional_value: p_di.Optional_Value<T>) => {};
+export declare const state: <State extends p_di.State>(state: State) => {};
+export declare const text: (string: string) => {};

package/dist/implementation/__internal/sync/production.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.text = exports.state = exports.optional = exports.number = exports.list = exports.dictionary = exports.boolean = void 0;
+const boolean = (boolean_value) => {
+    return {};
+};
+exports.boolean = boolean;
+const dictionary = (dictionary) => {
+    return {};
+};
+exports.dictionary = dictionary;
+const list = (list) => {
+    return {};
+};
+exports.list = list;
+const number = (number) => {
+    return {};
+};
+exports.number = number;
+const optional = (optional_value) => {
+    return {};
+};
+exports.optional = optional;
+const state = (state) => {
+    return {};
+};
+exports.state = state;
+const text = (string) => {
+    return {};
+};
+exports.text = text;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvZHVjdGlvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9pbXBsZW1lbnRhdGlvbi9fX2ludGVybmFsL3N5bmMvcHJvZHVjdGlvbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFNVyxNQUFNLE9BQU8sR0FBRyxDQUNuQixhQUFzQixFQUN4QixFQUFFO0lBQ0EsT0FBTyxFQUlOLENBQUE7QUFDTCxDQUFDLENBQUE7QUFSWSxRQUFBLE9BQU8sV0FRbkI7QUFFTSxNQUFNLFVBQVUsR0FBRyxDQUN0QixVQUE4QixFQUNoQyxFQUFFO0lBQ0EsT0FBTyxFQUdOLENBQUE7QUFDTCxDQUFDLENBQUE7QUFQWSxRQUFBLFVBQVUsY0FPdEI7QUFFTSxNQUFNLElBQUksR0FBRyxDQUNoQixJQUFrQixFQUNwQixFQUFFO0lBQ0EsT0FBTyxFQUdOLENBQUE7QUFDTCxDQUFDLENBQUE7QUFQWSxRQUFBLElBQUksUUFPaEI7QUFNTSxNQUFNLE1BQU0sR0FBRyxDQUNsQixNQUFjLEVBQ2hCLEVBQUU7SUFDQSxPQUFPLEVBQ04sQ0FBQTtBQUNMLENBQUMsQ0FBQTtBQUxZLFFBQUEsTUFBTSxVQUtsQjtBQUVNLE1BQU0sUUFBUSxHQUFHLENBQ3BCLGNBQXNDLEVBQ3hDLEVBQUU7SUFDQSxPQUFPLEVBQ04sQ0FBQTtBQUNMLENBQUMsQ0FBQTtBQUxZLFFBQUEsUUFBUSxZQUtwQjtBQUlNLE1BQU0sS0FBSyxHQUFHLENBQ2pCLEtBQVksRUFDZCxFQUFFO0lBQ0EsT0FBTyxFQUNOLENBQUE7QUFDTCxDQUFDLENBQUE7QUFMWSxRQUFBLEtBQUssU0FLakI7QUFFTSxNQUFNLElBQUksR0FBRyxDQUNoQixNQUFjLEVBQ2hCLEVBQUU7SUFDQSxPQUFPLEVBQ04sQ0FBQTtBQUNMLENBQUMsQ0FBQTtBQUxZLFFBQUEsSUFBSSxRQUtoQiJ9

package/dist/implementation/__internal/sync/refine.d.ts

@@ -1,22 +1,20 @@
 import * as p_di from "../../../interface/data";
 import * as p_ri from "../../../interface/refiner";
 import { Abort } from "../../../interface/__internal/Abort";
-export declare namespace from {
-    const boolean: (boolean_value: boolean) => {};
-    const dictionary: <T extends p_di.Value>(dictionary: p_di.Dictionary<T>) => {
-        map: <New_Type extends p_di.Value>(assign_entry: (value: T, id: string) => New_Type) => p_di.Dictionary<New_Type>;
-        resolve: <Resolved extends p_di.Value>(assign_entry: (value: T, id: string, acyclic_lookup: p_ri.lookup.Acyclic<Resolved>, cyclic_lookup: p_ri.lookup.Cyclic<Resolved>) => Resolved) => p_di.Dictionary<Resolved>;
-    };
-    const list: <T extends p_di.Value>(list: p_di.List<T>) => {
-        convert_to_dictionary: <NT extends p_di.Value>(get_id: (item: T) => string, get_value: (item: T) => NT, abort: {
-            duplicate_id: Abort<string>;
-        }) => p_di.Dictionary<NT>;
-        map: <New_Type extends p_di.Value>(assign_item: (item: T) => New_Type) => p_di.List<New_Type>;
-    };
-    namespace number {
-    }
-    const number: (number: number) => {};
-    const optional: <T extends p_di.Value>(optional_value: p_di.Optional_Value<T>) => {};
-    const state: <State extends p_di.State>(state: State) => {};
-    const text: (string: string) => {};
+export declare const boolean: (boolean_value: boolean) => {};
+export declare const dictionary: <T extends p_di.Value>(dictionary: p_di.Dictionary<T>) => {
+    map: <New_Type extends p_di.Value>(assign_entry: (value: T, id: string) => New_Type) => p_di.Dictionary<New_Type>;
+    resolve: <Resolved extends p_di.Value>(assign_entry: (value: T, id: string, acyclic_lookup: p_ri.lookup.Acyclic<Resolved>, cyclic_lookup: p_ri.lookup.Cyclic<Resolved>) => Resolved) => p_di.Dictionary<Resolved>;
+};
+export declare const list: <T extends p_di.Value>(list: p_di.List<T>) => {
+    convert_to_dictionary: <NT extends p_di.Value>(get_id: (item: T) => string, get_value: (item: T) => NT, abort: {
+        duplicate_id: Abort<string>;
+    }) => p_di.Dictionary<NT>;
+    map: <New_Type extends p_di.Value>(assign_item: (item: T) => New_Type) => p_di.List<New_Type>;
+};
+export declare namespace number {
 }
+export declare const number: (number: number) => {};
+export declare const optional: <T extends p_di.Value>(optional_value: p_di.Optional_Value<T>) => {};
+export declare const state: <State extends p_di.State>(state: State) => {};
+export declare const text: (string: string) => {};

package/dist/implementation/__internal/sync/refine.js

@@ -33,128 +33,132 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.from = void 0;
+exports.text = exports.state = exports.optional = exports.number = exports.list = exports.dictionary = exports.boolean = void 0;
 const lit = __importStar(require("./literal"));
-var from;
-(function (from) {
-    from.boolean = (boolean_value) => {
-        return {};
-    };
-    from.dictionary = (dictionary) => {
-        return {
-            map: (assign_entry) => dictionary.__d_map_deprecated(assign_entry),
-            resolve: (assign_entry) => {
-                const source = dictionary;
-                const out = {};
-                const entries_started = {};
-                const cyclic_references = [];
-                const inner_resolve = (value, id, stack) => {
-                    if (out[id] !== undefined) {
-                        // already resolved
-                        return;
-                    }
-                    entries_started[id] = null;
-                    out[id] = assign_entry(value, id, {
-                        get_entry: (id, abort) => {
+const boolean = (boolean_value) => {
+    return {};
+};
+exports.boolean = boolean;
+const dictionary = (dictionary) => {
+    return {
+        map: (assign_entry) => dictionary.__d_map_deprecated(assign_entry),
+        resolve: (assign_entry) => {
+            const source = dictionary;
+            const out = {};
+            const entries_started = {};
+            const cyclic_references = [];
+            const inner_resolve = (value, id, stack) => {
+                if (out[id] !== undefined) {
+                    // already resolved
+                    return;
+                }
+                entries_started[id] = null;
+                out[id] = assign_entry(value, id, {
+                    get_entry: (id, abort) => {
+                        if (out[id] === undefined) {
+                            if (entries_started[id] !== undefined) {
+                                return abort['cycle_detected'](lit.list(stack.concat([id])));
+                            }
+                            else {
+                                inner_resolve(source.__get_entry_deprecated(id, {
+                                    no_such_entry: () => abort.no_such_entry(null)
+                                }), id, stack.concat([id]));
+                            }
+                        }
+                        // now it must be resolved, otherwise we would have aborted
+                        return out[id];
+                    },
+                    __get_entry_raw: (id, abort) => {
+                        const x = source.__get_entry_raw(id);
+                        if (x === null) {
+                            return null;
+                        }
+                        else {
                             if (out[id] === undefined) {
                                 if (entries_started[id] !== undefined) {
-                                    return abort['cycle_detected'](lit.list(stack.concat([id])));
+                                    return abort.cycle_detected(lit.list(stack.concat([id])));
                                 }
                                 else {
-                                    inner_resolve(source.__get_entry_deprecated(id, {
-                                        no_such_entry: () => abort.no_such_entry(null)
-                                    }), id, stack.concat([id]));
+                                    inner_resolve(x[0], id, stack.concat([id]));
                                 }
                             }
                             // now it must be resolved, otherwise we would have aborted
-                            return out[id];
-                        },
-                        __get_entry_raw: (id, abort) => {
-                            const x = source.__get_entry_raw(id);
-                            if (x === null) {
-                                return null;
-                            }
-                            else {
-                                if (out[id] === undefined) {
-                                    if (entries_started[id] !== undefined) {
-                                        return abort.cycle_detected(lit.list(stack.concat([id])));
-                                    }
-                                    else {
-                                        inner_resolve(x[0], id, stack.concat([id]));
-                                    }
-                                }
-                                // now it must be resolved, otherwise we would have aborted
-                                return [out[id]];
-                            }
-                        }
-                    }, {
-                        get_entry: (id, abort) => {
-                            const temp_reference = {
-                                'id': id,
-                                'value': undefined,
-                                'abort': abort,
-                            };
-                            cyclic_references.push(temp_reference);
-                            return {
-                                get_circular_dependent: () => {
-                                    if (temp_reference.value === undefined) {
-                                        return abort.accessing_cyclic_sibling_before_it_is_resolved(null);
-                                    }
-                                    else {
-                                        return temp_reference.value;
-                                    }
-                                }
-                            };
+                            return [out[id]];
                         }
-                    });
-                };
-                source.__get_raw_copy().forEach(($) => {
-                    const id = $[0];
-                    const value = $[1];
-                    inner_resolve(value, id, [id]);
-                });
-                cyclic_references.forEach(($) => {
-                    const value = out[$.id];
-                    if (value === undefined) {
-                        $.abort.no_such_entry($.id);
-                    }
-                    else {
-                        $.value = value;
                     }
-                });
-                return lit.dictionary(out);
-            },
-        };
-    };
-    from.list = (list) => {
-        return {
-            convert_to_dictionary: (get_id, get_value, abort) => {
-                const temp = {};
-                list.__get_raw_copy().forEach(($) => {
-                    const id = get_id($);
-                    if (temp[id] !== undefined) {
-                        abort.duplicate_id(id);
+                }, {
+                    get_entry: (id, abort) => {
+                        const temp_reference = {
+                            'id': id,
+                            'value': undefined,
+                            'abort': abort,
+                        };
+                        cyclic_references.push(temp_reference);
+                        return {
+                            get_circular_dependent: () => {
+                                if (temp_reference.value === undefined) {
+                                    return abort.accessing_cyclic_sibling_before_it_is_resolved(null);
+                                }
+                                else {
+                                    return temp_reference.value;
+                                }
+                            }
+                        };
                     }
-                    temp[id] = get_value($);
                 });
-                return lit.dictionary(temp);
-            },
-            map: (assign_item) => {
-                return list.__l_map_deprecated(assign_item);
-            },
-        };
-    };
-    from.number = (number) => {
-        return {};
-    };
-    from.optional = (optional_value) => {
-        return {};
-    };
-    from.state = (state) => {
-        return {};
+            };
+            source.__get_raw_copy().forEach(($) => {
+                const id = $[0];
+                const value = $[1];
+                inner_resolve(value, id, [id]);
+            });
+            cyclic_references.forEach(($) => {
+                const value = out[$.id];
+                if (value === undefined) {
+                    $.abort.no_such_entry($.id);
+                }
+                else {
+                    $.value = value;
+                }
+            });
+            return lit.dictionary(out);
+        },
     };
-    from.text = (string) => {
-        return {};
+};
+exports.dictionary = dictionary;
+const list = (list) => {
+    return {
+        convert_to_dictionary: (get_id, get_value, abort) => {
+            const temp = {};
+            list.__get_raw_copy().forEach(($) => {
+                const id = get_id($);
+                if (temp[id] !== undefined) {
+                    abort.duplicate_id(id);
+                }
+                temp[id] = get_value($);
+            });
+            return lit.dictionary(temp);
+        },
+        map: (assign_item) => {
+            return list.__l_map_deprecated(assign_item);
+        },
     };
-})(from || (exports.from = from = {}));
-//# sourceMappingURL=data:application/json;base64,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
+};
+exports.list = list;
+const number = (number) => {
+    return {};
+};
+exports.number = number;
+const optional = (optional_value) => {
+    return {};
+};
+exports.optional = optional;
+const state = (state) => {
+    return {};
+};
+exports.state = state;
+const text = (string) => {
+    return {};
+};
+exports.text = text;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/implementation/__internal/sync/transform.d.ts

@@ -1,85 +1,83 @@
 import * as p_di from "../../../interface/data";
 import * as p_ti from "../../../interface/transformer";
 import { Abort } from "../../../interface/__internal/Abort";
-export declare namespace from {
-    const boolean: (boolean_value: boolean) => {
-        convert_to_optional: <T extends p_di.Value>(assign_set: () => T) => p_di.Optional_Value<T>;
-        decide: <RT>(if_true: () => RT, if_false: () => RT) => RT;
-    };
-    const dictionary: <T extends p_di.Value>(dictionary: p_di.Dictionary<T>) => {
-        amount_of_entries: () => number;
-        convert_to_list: <New_Type extends p_di.Value>(assign_item: (value: T, id: string) => New_Type) => p_di.List<New_Type>;
-        filter: (callback: (value: T, id: string) => boolean) => p_di.Dictionary<T>;
-        flatten: <New_Type extends p_di.Value>(get_child_dictionary: (value: T) => p_di.Dictionary<New_Type>, get_id: (parent_id: string, child_id: string) => string, abort: {
-            duplicate_id: Abort<string>;
-        }) => p_di.Dictionary<New_Type>;
-        flatten_to_list: <NT extends p_di.Value>(assign_item: (value: T, id: string) => p_di.List<NT>) => p_di.List<NT>;
-        group: (get_id: (value: T, id: string) => string) => p_di.Dictionary<p_di.Dictionary<T>>;
-        is_empty: () => boolean;
-        join: <Other_Type extends p_di.Value, Result extends p_di.Value>(other_dictionary: p_di.Dictionary<Other_Type>, assign_entry: (value: T, other_value: p_di.Optional_Value<Other_Type>, id: string) => Result) => p_di.Dictionary<Result>;
-        map: <New_Type extends p_di.Value>(assign_entry: (value: T, id: string) => New_Type) => p_di.Dictionary<New_Type>;
-        map_optionally: <New_Type extends p_di.Value>(assign_optional_entry: (value: T, id: string) => p_di.Optional_Value<New_Type>) => p_di.Dictionary<New_Type>;
-        on_contains_entry: <RT extends p_di.Value>(id: string, if_true: ($: T) => RT, if_not_true: () => RT) => RT;
-        on_has_entries: <RT extends p_di.Value>(if_true: ($: p_di.Dictionary<T>) => RT, if_not_true: () => RT) => RT;
-        on_has_single_entry: <RT extends p_di.Value>(if_true: ($: T, id: string) => RT, if_multiple: ($: p_di.Dictionary<T>) => RT, if_none: () => RT) => RT;
-        re_id: (get_id: ($: T, key: string) => string, abort: {
-            duplicate_id: (value: T, id: string) => never;
-        }) => p_di.Dictionary<T>;
-        resolve: <Resolved extends p_di.Value>(assign_entry: (value: T, id: string, acyclic_lookup: p_ti.lookup.Acyclic<Resolved>, cyclic_lookup: p_ti.lookup.Cyclic<Resolved>) => Resolved) => p_di.Dictionary<Resolved>;
-        sum: (assign_value: (item: T) => number) => number;
-    };
-    const list: <T extends p_di.Value>(list: p_di.List<T>) => {
-        amount_of_items: () => number;
-        convert_to_dictionary: <NT extends p_di.Value>(get_id: (item: T) => string, get_value: (item: T) => NT, abort: {
-            duplicate_id: Abort<string>;
-        }) => p_di.Dictionary<NT>;
-        filter: (callback: (item: T) => boolean) => p_di.List<T>;
-        flatten: <NT extends p_di.Value>(assign_list: ($: T) => p_di.List<NT>) => p_di.List<NT>;
-        full_join: <Other_Type extends p_di.Value, Result extends p_di.Value>(other_list: p_di.List<Other_Type>, assign_item: (value: p_di.Optional_Value<T>, other_value: p_di.Optional_Value<Other_Type>) => Result) => p_di.List<Result>;
-        group: (get_id: (item: T) => string) => p_di.Dictionary<p_di.List<T>>;
-        is_empty: () => boolean;
-        join: <Other_Type extends p_di.Value, Result_1 extends p_di.Value>(other_list: p_di.List<Other_Type>, assign_item: (value: T, other_value: p_di.Optional_Value<Other_Type>) => Result_1) => p_di.List<Result_1>;
-        map: <New_Type extends p_di.Value>(assign_item: (item: T) => New_Type) => p_di.List<New_Type>;
-        map_optionally: <New_Type extends p_di.Value>(assign_optional_item: (item: T) => p_di.Optional_Value<New_Type>) => p_di.List<New_Type>;
-        map_with_state: <Target_Item extends p_di.Value, State, Result_Type extends {
-            [id: string]: p_di.Value;
-        }>(initial_state: State, assign_item: (item: T, state: State) => Target_Item, update_state: (item: Target_Item, state: State) => State, wrapup: (final_list: p_di.List<Target_Item>, final_state: State) => Result_Type) => Result_Type;
-        on_has_first_item: <RT extends p_di.Value>(if_true: ($: T, rest: p_di.List<T>) => RT, if_not_true: () => RT) => RT;
-        on_has_items: <RT extends p_di.Value>(if_true: ($: p_di.List<T>) => RT, if_not_true: () => RT) => RT;
-        on_has_last_item: <RT extends p_di.Value>(if_true: ($: T, rest: p_di.List<T>) => RT, if_not_true: () => RT) => RT;
-        on_has_match: <RT extends p_di.Value>(test: ($: T) => p_di.Optional_Value<RT>, if_no_match: () => RT) => RT;
-        on_has_single_item: <RT extends p_di.Value>(if_true: ($: T) => RT, if_multiple: ($: p_di.List<T>) => RT, if_none: () => RT) => RT;
-        sum: (assign_value: (item: T) => number) => number;
-        reduce_to_boolean: (initial_state: boolean, update_state: (value: T, current: boolean) => boolean) => boolean;
-        reduce_to_number: (initial_state: number, update_state: (value: T, current: number) => number) => number;
-        reverse: () => p_di.List<T>;
-    };
-    const number: (number: number) => {
-        /**
-         * Performs integer division of two numbers with configurable rounding behavior.
-         *
-         * dividend / divisor
-         *
-         * Rounding modes:
-         * - 'towards negative infinity': floor (7.8 → 7, -7.8 → -8)
-         * - 'towards positive infinity': ceiling (7.2 → 8, -7.8 → -7)
-         * - 'towards zero': truncate (7.8 → 7, -7.8 → -7)
-         * - 'towards nearest': round to nearest integer (7.5 → 8, 7.4 → 7)
-         * - 'away from zero': round away from zero (7.2 → 8, -7.2 → -8)
-         */
-        divide: (divisor: number, round: ["towards negative infinity", null] | ["towards positive infinity", null] | ["towards nearest", null] | ["towards zero", null] | ["away from zero", null], abort: {
-            divided_by_zero: Abort<null>;
-        }) => number;
-    };
-    const optional: <T extends p_di.Value>(optional_value: p_di.Optional_Value<T>) => {
-        decide: <RT extends p_di.Value>(if_set: ($: T) => RT, if_not_set: () => RT) => RT;
-        is_set: () => boolean;
-        map: <New_Type extends p_di.Value>(assign_set_value: (value: T) => New_Type) => p_di.Optional_Value<New_Type>;
-    };
-    const state: <State extends p_di.State>(state: State) => {
-        decide: <RT extends p_di.Value>(assign: (output: State) => RT) => RT;
-    };
-    const text: (string: string) => {
-        state: <State extends p_di.State>(assign_state: ($: string) => State) => p_di.State;
-    };
-}
+export declare const boolean: (boolean_value: boolean) => {
+    convert_to_optional: <T extends p_di.Value>(assign_set: () => T) => p_di.Optional_Value<T>;
+    decide: <RT>(if_true: () => RT, if_false: () => RT) => RT;
+};
+export declare const dictionary: <T extends p_di.Value>(dictionary: p_di.Dictionary<T>) => {
+    amount_of_entries: () => number;
+    convert_to_list: <New_Type extends p_di.Value>(assign_item: (value: T, id: string) => New_Type) => p_di.List<New_Type>;
+    filter: (callback: (value: T, id: string) => boolean) => p_di.Dictionary<T>;
+    flatten: <New_Type extends p_di.Value>(get_child_dictionary: (value: T) => p_di.Dictionary<New_Type>, get_id: (parent_id: string, child_id: string) => string, abort: {
+        duplicate_id: Abort<string>;
+    }) => p_di.Dictionary<New_Type>;
+    flatten_to_list: <NT extends p_di.Value>(assign_item: (value: T, id: string) => p_di.List<NT>) => p_di.List<NT>;
+    group: (get_id: (value: T, id: string) => string) => p_di.Dictionary<p_di.Dictionary<T>>;
+    is_empty: () => boolean;
+    join: <Other_Type extends p_di.Value, Result extends p_di.Value>(other_dictionary: p_di.Dictionary<Other_Type>, assign_entry: (value: T, other_value: p_di.Optional_Value<Other_Type>, id: string) => Result) => p_di.Dictionary<Result>;
+    map: <New_Type extends p_di.Value>(assign_entry: (value: T, id: string) => New_Type) => p_di.Dictionary<New_Type>;
+    map_optionally: <New_Type extends p_di.Value>(assign_optional_entry: (value: T, id: string) => p_di.Optional_Value<New_Type>) => p_di.Dictionary<New_Type>;
+    on_contains_entry: <RT extends p_di.Value>(id: string, if_true: ($: T) => RT, if_not_true: () => RT) => RT;
+    on_has_entries: <RT extends p_di.Value>(if_true: ($: p_di.Dictionary<T>) => RT, if_not_true: () => RT) => RT;
+    on_has_single_entry: <RT extends p_di.Value>(if_true: ($: T, id: string) => RT, if_multiple: ($: p_di.Dictionary<T>) => RT, if_none: () => RT) => RT;
+    re_id: (get_id: ($: T, key: string) => string, abort: {
+        duplicate_id: (value: T, id: string) => never;
+    }) => p_di.Dictionary<T>;
+    resolve: <Resolved extends p_di.Value>(assign_entry: (value: T, id: string, acyclic_lookup: p_ti.lookup.Acyclic<Resolved>, cyclic_lookup: p_ti.lookup.Cyclic<Resolved>) => Resolved) => p_di.Dictionary<Resolved>;
+    sum: (assign_value: (item: T) => number) => number;
+};
+export declare const list: <T extends p_di.Value>(list: p_di.List<T>) => {
+    amount_of_items: () => number;
+    convert_to_dictionary: <NT extends p_di.Value>(get_id: (item: T) => string, get_value: (item: T) => NT, abort: {
+        duplicate_id: Abort<string>;
+    }) => p_di.Dictionary<NT>;
+    filter: (callback: (item: T) => boolean) => p_di.List<T>;
+    flatten: <NT extends p_di.Value>(assign_list: ($: T) => p_di.List<NT>) => p_di.List<NT>;
+    full_join: <Other_Type extends p_di.Value, Result extends p_di.Value>(other_list: p_di.List<Other_Type>, assign_item: (value: p_di.Optional_Value<T>, other_value: p_di.Optional_Value<Other_Type>) => Result) => p_di.List<Result>;
+    group: (get_id: (item: T) => string) => p_di.Dictionary<p_di.List<T>>;
+    is_empty: () => boolean;
+    join: <Other_Type extends p_di.Value, Result_1 extends p_di.Value>(other_list: p_di.List<Other_Type>, assign_item: (value: T, other_value: p_di.Optional_Value<Other_Type>) => Result_1) => p_di.List<Result_1>;
+    map: <New_Type extends p_di.Value>(assign_item: (item: T) => New_Type) => p_di.List<New_Type>;
+    map_optionally: <New_Type extends p_di.Value>(assign_optional_item: (item: T) => p_di.Optional_Value<New_Type>) => p_di.List<New_Type>;
+    map_with_state: <Target_Item extends p_di.Value, State, Result_Type extends {
+        [id: string]: p_di.Value;
+    }>(initial_state: State, assign_item: (item: T, state: State) => Target_Item, update_state: (item: Target_Item, state: State) => State, wrapup: (final_list: p_di.List<Target_Item>, final_state: State) => Result_Type) => Result_Type;
+    on_has_first_item: <RT extends p_di.Value>(if_true: ($: T, rest: p_di.List<T>) => RT, if_not_true: () => RT) => RT;
+    on_has_items: <RT extends p_di.Value>(if_true: ($: p_di.List<T>) => RT, if_not_true: () => RT) => RT;
+    on_has_last_item: <RT extends p_di.Value>(if_true: ($: T, rest: p_di.List<T>) => RT, if_not_true: () => RT) => RT;
+    on_has_match: <RT extends p_di.Value>(test: ($: T) => p_di.Optional_Value<RT>, if_no_match: () => RT) => RT;
+    on_has_single_item: <RT extends p_di.Value>(if_true: ($: T) => RT, if_multiple: ($: p_di.List<T>) => RT, if_none: () => RT) => RT;
+    sum: (assign_value: (item: T) => number) => number;
+    reduce_to_boolean: (initial_state: boolean, update_state: (value: T, current: boolean) => boolean) => boolean;
+    reduce_to_number: (initial_state: number, update_state: (value: T, current: number) => number) => number;
+    reverse: () => p_di.List<T>;
+};
+export declare const number: (number: number) => {
+    /**
+     * Performs integer division of two numbers with configurable rounding behavior.
+     *
+     * dividend / divisor
+     *
+     * Rounding modes:
+     * - 'towards negative infinity': floor (7.8 → 7, -7.8 → -8)
+     * - 'towards positive infinity': ceiling (7.2 → 8, -7.8 → -7)
+     * - 'towards zero': truncate (7.8 → 7, -7.8 → -7)
+     * - 'towards nearest': round to nearest integer (7.5 → 8, 7.4 → 7)
+     * - 'away from zero': round away from zero (7.2 → 8, -7.2 → -8)
+     */
+    divide: (divisor: number, round: ["towards negative infinity", null] | ["towards positive infinity", null] | ["towards nearest", null] | ["towards zero", null] | ["away from zero", null], abort: {
+        divided_by_zero: Abort<null>;
+    }) => number;
+};
+export declare const optional: <T extends p_di.Value>(optional_value: p_di.Optional_Value<T>) => {
+    decide: <RT extends p_di.Value>(if_set: ($: T) => RT, if_not_set: () => RT) => RT;
+    is_set: () => boolean;
+    map: <New_Type extends p_di.Value>(assign_set_value: (value: T) => New_Type) => p_di.Optional_Value<New_Type>;
+};
+export declare const state: <State extends p_di.State>(state: State) => {
+    decide: <RT extends p_di.Value>(assign: (output: State) => RT) => RT;
+};
+export declare const text: (string: string) => {
+    state: <State extends p_di.State>(assign_state: ($: string) => State) => p_di.State;
+};