pareto 0.56.0 → 0.57.0

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/boolean/api.data.ts

@@ -0,0 +1,21 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "array_and": algorithm("Array And", null, {}),
+        "array_or": algorithm("Array Or", null, {}),
+        "array_xor": algorithm("Array Xor", null, {}),
+        "and": algorithm("And", null, {}),
+        "or": algorithm("Or", null, {}),
+        "xor": algorithm("Xor", null, {}),
+        "not": algorithm("Not", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/boolean/glossary.data.ts

@@ -0,0 +1,45 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array,
+    boolean,
+    data,
+    externalTypeReference,
+    group,
+    member,
+    number,
+    sfunction,
+    type,
+    typeReference,
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Boolean": type(boolean()),
+            "Pair Of Booleans": type(group({
+                "yin": member(boolean()),
+                "yang": member(boolean()),
+            })),
+            "Array Of Booleans": type(array(boolean())),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Array And": sfunction(typeReference("Boolean"), data(typeReference("Array Of Booleans"))),
+        "Array Or": sfunction(typeReference("Boolean"), data(typeReference("Array Of Booleans"))),
+        "Array Xor": sfunction(typeReference("Boolean"), data(typeReference("Array Of Booleans"))),
+        "And": sfunction(typeReference("Boolean"), data(typeReference("Pair Of Booleans"))),
+        "Or": sfunction(typeReference("Boolean"), data(typeReference("Pair Of Booleans"))),
+        "Xor": sfunction(typeReference("Boolean"), data(typeReference("Pair Of Booleans"))),
+        "Not": sfunction(typeReference("Boolean"), data(typeReference("Boolean"))),
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/build/api.data.ts

@@ -0,0 +1,25 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, taggedUnion, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        // "buildArray": algorithm("BuildArray", null, {}),
+        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", null, {}),
+        // "buildSafeDictionary": algorithm("BuildSafeDictionary", "DictionaryBuildStrategy", {}, {
+        // }),
+        "createUnsafeDictionaryBuilder": algorithm("CreateUnsafeDictionaryBuilder", null, {}),
+        "createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", "DictionaryBuildStrategy", {}),
+        "createArrayBuilder": algorithm("CreateArrayBuilder", null, {}),
+
+
+        "createStringBuilder": algorithm("CreateStringBuilder", "Startstring", {
+        }),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/build/glossary.data.ts

@@ -0,0 +1,133 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, dictionary, ref, typeParameter, group, sInf, member,
+    sfunction,
+    sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
+    infInit
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+
+            "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "Simple String": type(string()),
+
+            "Array": parametrizedType({ "Type": null, "EndType": null }, group({
+                "array": member(array(ref(typeParameter("Type")))),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
+                "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "String": parametrizedType({ "EndType": null }, group({
+                "string": member(string()),
+                "end": member(ref(typeParameter("EndType"))),
+            })),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
+
+
+
+
+            "DictionaryBuildStrategy": type(taggedUnion({
+                "ignore": group({}),
+                "overwrite": group({}),
+            })),
+            "Startstring": type(string()),
+        }),
+    },
+    'interface types': d({
+        "Array": aInterface(aInterfaceMethod(typeReference("Array", {
+            "Type": typeParameter("Type"),
+            "EndType": typeParameter("EndType")
+        })), { "Type": null, "EndType": null }),
+        "Dictionary": aInterface(aInterfaceMethod(typeReference("Dictionary", {
+            "Type": typeParameter("Type"),
+            "EndType": typeParameter("EndType")
+        })), { "Type": null, "EndType": null }),
+        "Elements": aInterface(streamconsumer(
+            aInterfaceMethod(typeParameter("Type")),
+            aInterfaceMethod(typeParameter("EndType")),
+        ), { "Type": null, "EndType": null }),
+        "Entries": aInterface(streamconsumer(
+            aInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })),
+            aInterfaceMethod(typeParameter("EndType")),
+        ), { "Type": null, "EndType": null }),
+        "DuplicatesHandler": aInterface(streamconsumer(
+            aInterfaceMethod(typeReference("Simple String")),
+            aInterfaceMethod(null),
+        )),
+        "StringConsumer": aInterface(aInterfaceMethod(typeReference("String", { "EndType": typeParameter("EndType") })), { "EndType": null }),
+        "StringStreamConsumer": aInterface(streamconsumer(
+            aInterfaceMethod(typeReference("Simple String")),
+            aInterfaceMethod(typeParameter("EndType")),
+        ), { "EndType": null }),
+        "Add": sInterface(sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })), { "Type": null }),
+        "Push": sInterface(sInterfaceMethod(typeParameter("Type")), { "Type": null }),
+
+
+
+
+    }),
+    'algorithm types': d({
+        "CreateArrayBuilder": infInit(aInterfaceReference("Elements", {
+            "Type": typeParameter("Type"),
+            "EndType": typeParameter("EndType"),
+        }), {
+            "handler": aInterfaceReference("Array", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType"),
+            }),
+        }, { "Type": null, "EndType": null }),
+        "CreateUnsafeDictionaryBuilder": infInit(aInterfaceReference("Entries", {
+            "Type": typeParameter("Type"),
+            "EndType": typeParameter("EndType"),
+        }), {
+            "handler": aInterfaceReference("Dictionary", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType")
+            }),
+        }, { "Type": null, "EndType": null }),
+        "CreateSafeDictionaryBuilder": infInit(aInterfaceReference("Entries", {
+            "Type": typeParameter("Type"),
+            "EndType": typeParameter("EndType"),
+        }), {
+            "handler": aInterfaceReference("Dictionary", {
+                "Type": typeParameter("Type"),
+                "EndType": typeParameter("EndType")
+            }),
+            "duplicatesHandler": aInterfaceReference("DuplicatesHandler"),
+
+        }, { "Type": null, "EndType": null }),
+        "CreateStringBuilder": infInit(aInterfaceReference("StringStreamConsumer", { "EndType": typeParameter("EndType") }), {
+            "handler": aInterfaceReference("StringConsumer", { "EndType": typeParameter("EndType") }),
+        }, { "EndType": null }),
+        // "BuildArray": sfunction(typeReference("Simple Array", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Push", { "Type": typeParameter("Type") })), { "Type": null }),
+        // "BuildUnsafeDictionary": sfunction(typeReference("Simple Dictionary", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
+        // "BuildSafeDictionary": sfunction(typeReference("Simple Dictionary", {
+        //     "Type": typeParameter("Type"),
+        // }), sInf(sInterfaceReference("Add", { "Type": typeParameter("Type") })), { "Type": null }),
+
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/dictionary/api.data.ts

@@ -0,0 +1,49 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterface, sInterfaceMethod, streamconsumer, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "filter": algorithm("Filter", null, {}),
+        /**
+         * a dictionary with containing entries with values and a key candidate is transformed
+         * into a dictionary where the new key of the entry is the candidate. If candidates are not unique
+         * the function panics
+         */
+        "unsafeRekey": algorithm("UnsafeRekey", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. If keys are not unique this function panics.
+         */
+        "unsafeMerge": algorithm("UnsafeMerge", null, {}),
+        /**
+         * a key/value pair is added to a dictionary resulting in a new dictionary.
+         * if the key is not unique the function panics
+         */
+        "unsafeAddEntry": algorithm("UnsafeAddEntry", null, {}),
+        /**
+         * a focus dictionary is matched to a benchmark dictionary resulting in a result dictionary
+         * this last dictionary contains all entries found in the benchmark dictionary.
+         * each entry value is optionally supplemented with the value of the focus entry, if found.
+         */
+        "zip": algorithm("Zip", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the last dictionary will be used.
+         */
+        "mergeAndOverwrite": algorithm("MergeAndOverwrite", null, {}),
+        /**
+         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
+         */
+        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
+        /**
+         * 2 dictionaries are combined into 1 dictionary. is a key exists in both directories, only the entry of the first dictionary will be used.
+         */
+        "mergeAndIgnore": algorithm("MergeAndIgnore", null, {}),
+        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/dictionary/glossary.data.ts

@@ -0,0 +1,119 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    dictionary,
+    typeReference,
+    data,
+    sfunction,
+    ref,
+    typeParameter,
+    externalTypeReference,
+    parametrizedType,
+    optional,
+    group,
+    member,
+    aInterface,
+    streamconsumer,
+    aInterfaceMethod,
+    type,
+    string,
+    boolean,
+    sInterface,
+    sInterfaceMethod,
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Boolean": type(boolean()),
+            "String": type(string()),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
+            "MergeParameters": parametrizedType({ "Type": null }, group({
+                "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+            })),
+            "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
+                "benchmark": member(ref(typeParameter("Benchmark"))),
+                "focus": member(optional(ref(typeParameter("Focus")))),
+            }))),
+
+            "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
+            })),
+            "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
+                "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
+                "separator": member(string()),
+                "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
+            })),
+            "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
+                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+            })),
+            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+
+
+            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "Filter": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("FilterableDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeRekey": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("RekeyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeMerge": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeAddEntry": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("UnsafeAddEntryParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "MergeAndIgnore": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "Zip": sfunction(
+            typeReference("ZippedDictionary", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
+            data(typeReference("DictionaryTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
+            { "Benchmark": null, "Focus": null }
+        ),
+        "FlattenDictionaryOfDictionaries": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("FlattenDictionaryOfDictionariesParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "MergeAndOverwrite": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),       
+         "DecorateDictionaryEntriesWithKey": sfunction(typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }), data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }),
+
+    }),
+
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/json/api.data.ts

@@ -0,0 +1,15 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "serialize": algorithm("Serialize", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/json/glossary.data.ts

@@ -0,0 +1,47 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, afunction, boolean, computed, data, dictionary,
+    glossaryParameter, group, member, number, optional, ref, sfunction, string, type, typeReference,
+    taggedUnion,
+    null_,
+    sInterface,
+    sInterfaceMethod
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({
+    }),
+    'imports': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "Result": type(taggedUnion({
+                "success": ref(typeReference("Value")),
+                "error": string(),
+            })),
+            //"Result": type(ref(glossaryParameter("Type"))),
+            "Value": type(taggedUnion({
+                "object": dictionary(ref(typeReference("Value"))),
+                "array": array(ref(typeReference("Value"))),
+                "string": string(),
+                "number": number(),
+                "boolean": boolean(),
+                "null": null_(),
+            })),
+
+
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+        "Serialize": sfunction(typeReference("String"), data(typeReference("Value"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/nested/api.data.ts

@@ -0,0 +1,15 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "flatten": algorithm("Flatten", null, {})
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/nested/glossary.data.ts

@@ -0,0 +1,29 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, glossaryParameter, group, member, null_, parametrizedType, ref, sfunction, string, taggedUnion, type, typeParameter, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Nested": parametrizedType({ "Type": null }, taggedUnion({
+                "single": ref(typeParameter("Type")),
+                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type")}))),
+                "none": null_(),
+            })),
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Flatten": sfunction(typeReference("Array", { "Type": typeParameter("Type")}), data(typeReference("Nested", { "Type": typeParameter("Type")})), { "Type": null })
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/resolve/api.data.ts

@@ -0,0 +1,15 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/resolve/glossary.data.ts

@@ -0,0 +1,52 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    string, member, group,
+    typeReference,
+    data,
+    sfunction,
+    type,
+    externalTypeReference,
+    boolean,
+    parametrizedType,
+    dictionary,
+    ref,
+    typeParameter,
+    array,
+    null_,
+    computed,
+    sInterface,
+    sInterfaceMethod,
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
+            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                "value": member(ref(typeParameter("Type"))),
+                "dependencies": member(dictionary(null_())),
+            }))),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "SortTopologically": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/string/api.data.ts

@@ -0,0 +1,17 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'pareto/auto.dist/public/shorthands/cosmos'
+
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "join": algorithm("Join", null, {}),
+        "repeat": algorithm("Repeat", null, {}),
+        "foo": algorithm("Foo", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/string/glossary.data.ts

@@ -0,0 +1,39 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
+} from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_glossary from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "JoinData": type(group({
+                "first": member(string()),
+                "second": member(string()),
+            })),
+            "RepeatData": type(group({
+                "contextString": member(string()),
+                "times": member(number()),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+
+        "Join": sfunction(typeReference("String"), data(typeReference("JoinData"))),
+        "Repeat": sfunction(typeReference("String"), data(typeReference("RepeatData"))),
+        "Foo": sfunction(typeReference("String"), data(typeReference("String"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/tostring/api.data.ts

@@ -0,0 +1,19 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, member, type, group, string, optional, number } from 'pareto/auto.dist/public/shorthands/cosmos'
+export const $: g_project.D.API = api(
+    glos,
+    {
+        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
+        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
+        "getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
+
+        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
+
+    }
+)