pareto 0.51.1 → 0.53.0

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/foreach/api.data.ts

@@ -0,0 +1,25 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, sibling, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+// import { $ as g_collation } from "../collation/glossary.data"
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "arrayForEach": algorithm("ArrayForEach", null, {}),
+        "dictionaryForEach": algorithm("DictionaryForEach", null, {
+            //FIXME "compare": sibling("collation", "IsABeforeB"),
+        }),
+        "enrichedArrayForEach": algorithm("EnrichedArrayForEach", null, {}),
+        "enrichedDictionaryForEach": algorithm("EnrichedDictionaryForEach", null, {
+            //FIXME "compare": sibling("collation", "IsABeforeB"),
+        }),
+        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/foreach/glossary.data.ts

@@ -0,0 +1,78 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    string,
+    dictionary, member, group,
+    array,
+    typeReference,
+    boolean,
+    ref,
+    sInterfaceMethod,
+    sfunction,
+    data,
+    procedure,
+    sInterfaceReference,
+    parametrizedType,
+    typeParameter,
+    sInterface,
+    optional,
+
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "AnnotatedEntry": parametrizedType({ "Type": null }, group({
+                "isFirst": member(boolean()),
+                "isLast": member(boolean()),
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "AnnotatedElement": parametrizedType({ "Type": null }, group({
+                "isFirst": member(boolean()),
+                "isLast": member(boolean()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+
+
+        }),
+    },
+    'interface types': d({
+        "OnElement": sInterface(sInterfaceMethod(typeParameter("Type")), { "Type": null }),
+        "OnEntry": sInterface(sInterfaceMethod(typeReference("KeyValuePair", { "Type": typeParameter("Type") })), { "Type": null }),
+        "OnEnrichedDictionary": sInterface(['group', {
+            'members': d({
+                "onEmpty": sInterfaceMethod(null),
+                "onNotEmpty": sInterfaceMethod(null, sInterfaceMethod(typeReference("AnnotatedEntry", { "Type": typeParameter("Type") }))),
+            }),
+        }], { "Type": null }),
+        "OnEnrichedArray": sInterface(['group', {
+            'members': d({
+                "onEmpty": sInterfaceMethod(null),
+                "onNotEmpty": sInterfaceMethod(null, sInterfaceMethod(typeReference("AnnotatedElement", { "Type": typeParameter("Type") }))),
+            }),
+        }], { "Type": null }),
+    }),
+    'algorithm types': d({
+        "ArrayForEach": procedure(data(typeReference("Array", { "Type": typeParameter("Type") })), sInterfaceReference("OnElement", { "Type": typeParameter("Type") }), { "Type": null }),
+        "DictionaryForEach": procedure(data(typeReference("Dictionary", { "Type": typeParameter("Type") })), sInterfaceReference("OnEntry", { "Type": typeParameter("Type") }), { "Type": null }),
+        "EnrichedDictionaryForEach": procedure(data(typeReference("Dictionary", { "Type": typeParameter("Type") })), sInterfaceReference("OnEnrichedDictionary", { "Type": typeParameter("Type") }), { "Type": null }),
+        "EnrichedArrayForEach": procedure(data(typeReference("Array", { "Type": typeParameter("Type") })), sInterfaceReference("OnEnrichedArray", { "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-standard-impure-library/modules/http/api.data.ts

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { array, glossary, group, member, number, ref, string, taggedUnion, type, typeReference } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "initializeHTTPServerProxy": algorithm("Initialize HTTP Server Proxy", "Configuration", {}),
+        "initializeHTTPSServerProxy": algorithm("Initialize HTTP Server Proxy", "Configuration", {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/http/glossary.data.ts

@@ -0,0 +1,69 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface, aInterfaceMethod, aInterfaceReference, array, boolean,
+    group, member, ref, resource, streamconsumer, string, taggedUnion, type, typeReference
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Path": type(array(string())),
+            "EncounteredErrors": type(boolean()),
+            "Data": type(taggedUnion({
+                "error": ref(typeReference("HTTPError")),
+                "data": string()
+            })),
+            "HTTPError": type(taggedUnion({
+                "unknown": string(),
+            })),
+
+
+            "Configuration": type(group({
+                "hostName": member(string()),
+                "contextPath": member(ref(typeReference("Path"))),
+            })),
+        }),
+    },
+    'interface types': d({
+
+        //"HandleError": interfaceMethod(typeReference("HTTPError")),
+        // "ProcessHTTPResource": func(typeReference("common", "Path"), null, builderReference("Init"), null),
+        //"Init": aInterface(aInterfaceMethod(null, ['reference', aInterfaceReference("StreamConsumer")])),
+        // "Init": ['choice', {
+        //     'options': d({
+        //         "success": ['reference', aInterfaceReference("StreamConsumer")],
+        //         "error": ['reference', aInterfaceReference("ErrorStreamConsumer")],
+        //     })
+        // }],
+        // "Init": builderMethod(null, ['reference', {
+        //     'context': ['local', null],
+        //     'interface': "StreamConsumer"
+        // }], false),
+        // "StreamConsumer": aInterface(streamconsumer(
+        //     aInterfaceMethod(externalTypeReference("common", "String")),
+        //     aInterfaceMethod(typeReference("EncounteredErrors")),
+        // )),
+        "Consumer": aInterface(streamconsumer(
+            aInterfaceMethod(typeReference("Data")),
+            aInterfaceMethod(null),
+        )),
+    }),
+    'algorithm types': d({
+        "Initialize HTTP Server Proxy": resource(typeReference("Path"), aInterfaceReference("Consumer")),
+        // "HTTPRequest": a(, {
+        //     "init": aInterfaceReference("Init"),
+        //     "errorConsumer": aInterfaceReference("ErrorStreamConsumer")
+        // })
+
+    }),
+
+}

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

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "convertJSON": algorithm("ConvertJSON", null, {}),
+        "unsafeConvertJSON": algorithm("UnsafeConvertJSON", null, {}),
+    }
+)

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

@@ -0,0 +1,51 @@
+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 "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({
+    }),
+    'imports': d({}),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "Result": type(taggedUnion({
+                "success": ref(typeReference("JSONValue")),
+                "error": string(),
+            })),
+            //"Result": type(ref(glossaryParameter("Type"))),
+            "JSONValue": type(taggedUnion({
+                "object": dictionary(ref(typeReference("JSONValue"))),
+                "array": array(ref(typeReference("JSONValue"))),
+                "string": string(),
+                "number": number(),
+                "boolean": boolean(),
+                "null": null_(),
+            })),
+
+
+        }),
+    },
+    'interface types': d({
+
+    }),
+    'algorithm types': d({
+        "ConvertJSON": sfunction(typeReference("Result"), data(typeReference("String"))),
+
+        /*use this one if the application may crash if the JSON is invalid*/
+        "UnsafeConvertJSON": sfunction(typeReference("JSONValue"), data(typeReference("String"))),
+        //"Convert": sfunction(typeReference("Result"), data(typeReference("JSONValue"))),
+    }),
+}

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

@@ -0,0 +1,15 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "flatten": algorithm("Flatten", null, {})
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-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 "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    '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-standard-impure-library/modules/numerical_predicates/api.data.ts

@@ -0,0 +1,18 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "smallerThan": algorithm("SmallerThan", null, {}),
+        "greaterThan": algorithm("GreaterThan", null, {}),
+        "isZero": algorithm("IsZero", null, {}),
+        "equal": algorithm("Equal", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/numerical_predicates/glossary.data.ts

@@ -0,0 +1,40 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
+    type, typeReference
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Boolean": type(boolean()),
+            "Number": type(number()),
+            "NumberPair": type(group({
+                "yin": member(number()),
+                "yang": member(number()),
+            })),
+            "CompareData": type(group({
+                "benchmark": member(number()),
+                "focus": member(number()),
+            })),
+
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "IsZero": sfunction(typeReference("Boolean"), data(typeReference("Number"))),
+
+        "GreaterThan": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
+        "SmallerThan": sfunction(typeReference("Boolean"), data(typeReference("CompareData"))),
+        "Equal": sfunction(typeReference("Boolean"), data(typeReference("NumberPair"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/path/api.data.ts

@@ -0,0 +1,19 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+
+        "convertWindowsPathToPosixPath": algorithm("ConvertWindowsPathToPosixPath", null, {}),
+        "basename": algorithm("Basename", null, {}),
+        "dirname": algorithm("Dirname", null, {}),
+        "parseFilePath": algorithm("ParseFilePath", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-standard-impure-library/modules/path/glossary.data.ts

@@ -0,0 +1,35 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, externalTypeReference, group, member, sfunction, string, type, typeReference
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "ParseFilePathData": type(group({
+                "filePath": member(string()),
+                "pathSeparator": member(string()),
+            })),
+            "ParsedFilePath": type(group({
+                "directoryPath": member(array(string())),
+                "baseName": member(string()),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "ConvertWindowsPathToPosixPath": sfunction(typeReference("String"), data(typeReference("String"))),
+        "Basename": sfunction(typeReference("String"), data(typeReference("String"))),
+        "Dirname": sfunction(typeReference("String"), data(typeReference("String"))),
+        "ParseFilePath": sfunction(typeReference("ParsedFilePath"), data(typeReference("ParseFilePathData"))),
+    }),
+}

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

@@ -0,0 +1,20 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+        "sortTopologically": algorithm("SortTopologically", null, {}),
+        // "unsafeResolveDictionary": algorithm("UnsafeResolveDictionary", null, {}),
+        // "safeResolveDictionary": algorithm("SafeResolveDictionary", null, {
+        // }, {
+        //     "onError": sideEffect("OnError", 'sync')
+        // }),
+    }
+)

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

@@ -0,0 +1,84 @@
+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 "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters':d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+            "KeyValuePair": parametrizedType({ "Type": null }, group({
+                "key": member(string()),
+                "value": member(ref(typeParameter("Type"))),
+            })),
+            "AnySibling": parametrizedType({ "Type": null }, computed(ref(typeParameter("Type")))),
+
+            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
+                "value": member(ref(typeParameter("Type"))),
+                "dependencies": member(dictionary(null_())),
+            }))),
+
+
+            "Error": type(string()),
+
+        }),
+    },
+    'interface types': d({
+        "OnError": sInterface(sInterfaceMethod(typeReference("Error"))),
+
+
+    }),
+    'algorithm types': d({
+        "SortTopologically": sfunction(
+            typeReference("Array", { "Type": typeParameter("Type") }),
+            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        // "UnsafeResolveDictionary": scallbackfunction(
+        //     typeReference("Dictionary", { "Type": typeParameter("Out") }),
+        //     data(typeReference("Dictionary", { "Type": typeParameter("In") })),
+        //     {
+        //         "map": scallback(typeParameter("Out"), typeReference("KeyValuePair", { "Type": typeParameter("In") }), {
+        //             "non circular siblings": typeParameter("Out"),
+        //             "all siblings": typeReference("AnySibling", { "Type": typeParameter("Out") }),
+        //         })
+        //     },
+        //     { "In": null, "Out": null }
+        // ),
+        // "SafeResolveDictionary": scallbackfunction(
+        //     typeReference("Dictionary", { "Type": typeParameter("Out") }),
+        //     data(typeReference("Dictionary", { "Type": typeParameter("In") })),
+        //     {
+        //         "map": scallback(typeParameter("Out"), typeReference("KeyValuePair", { "Type": typeParameter("In") }), {
+        //             "non circular siblings": typeParameter("Out"),
+        //             "all siblings": typeReference("AnySibling", { "Type": typeParameter("Out") }),
+        //         })
+        //     },
+        //     { "In": null, "Out": null }
+        // ),
+    }),
+}

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

@@ -0,0 +1,26 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_project from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+import { $ as glos } from "./glossary.data"
+import { glossary, group, member, number, type } from 'lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands'
+
+export const $: g_project.D.API<pd.SourceLocation> = api(
+    glos,
+    {
+
+        "escape": algorithm("Escape", null, {}),
+        "fromCharacterArray": algorithm("FromCharacterArray", null, {}),
+        "join": algorithm("Join", null, {}),
+        "length": algorithm("Length", null, {}),
+        "replaceAll": algorithm("ReplaceAll", null, {}),
+        "split": algorithm("Split", null, {}),
+        "splitIn2": algorithm("SplitIn2", null, {}),
+        "startsWith": algorithm("StartsWith", null, {}),
+        "substr": algorithm("Substr", null, {}),
+        "toCharacterArray": algorithm("ToCharacterArray", null, {}),
+        "trimEnd": algorithm("TrimEnd", null, {}),
+    }
+)

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

@@ -0,0 +1,75 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    aInterface,
+    aInterfaceMethod,
+    aInterfaceReference,
+    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
+} from "lib-pareto-typescript-project/dist/modules/pareto_type_system/shorthands"
+
+import * as g_glossary from "lib-pareto-typescript-project/dist/modules/pareto_type_system"
+
+const d = pd.d
+
+export const $: g_glossary.D.Glossary<pd.SourceLocation> = {
+    'glossary parameters': d({}),
+    'imports': d({
+    }),
+    'root': {
+        'namespaces': d({}),
+        'data types': d({
+            "String": type(string()),
+            "Length": type(number()),
+            "Boolean": type(boolean()),
+            "CharacterArray": type(array(number())),
+            "SplitData": type(group({
+                "value": member(string()),
+                "splitter": member(string()),
+            })),
+            "SplitIn2Result": type(group({
+                "head": member(string()),
+                "tail": member(optional(string())),
+            })),
+            "SplitResult": type(array(string())),
+            "StartsWithData": type(group({
+                "contextString": member(string()),
+                "searchString": member(string()),
+            })),
+            "SubstrData": type(group({
+                "value": member(string()),
+                "begin": member(number()),
+                "length": member(number()),
+            })),
+            "ReplaceAllData": type(group({
+                "value": member(string()),
+                "pattern": member(string()),
+                "replacement": member(string()),
+            })),
+            "JoinData": type(group({
+                "first": member(string()),
+                "second": member(string()),
+            })),
+
+            "EscapeParameters": type(group({
+                "string": member(string()),
+                "escape": member(string()),
+                "patterns to escape": member(array(string())),
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Escape": sfunction(typeReference("String"), data(typeReference("EscapeParameters"))),
+
+        "ReplaceAll": sfunction(typeReference("String"), data(typeReference("ReplaceAllData"))),
+        "Substr": sfunction(typeReference("String"), data(typeReference("SubstrData"))),
+        "ToCharacterArray": sfunction(typeReference("CharacterArray"), data(typeReference("String"))),
+        "Join": sfunction(typeReference("String"), data(typeReference("JoinData"))),
+        "FromCharacterArray": sfunction(typeReference("String"), data(typeReference("CharacterArray"))),
+        "Split": sfunction(typeReference("SplitResult"), data(typeReference("SplitData"))),
+        "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
+        "Length": sfunction(typeReference("Length"), data(typeReference("String"))),
+        "TrimEnd": sfunction(typeReference("String"), data(typeReference("String"))),
+        "StartsWith": sfunction(typeReference("Boolean"), data(typeReference("StartsWithData"))),
+    }),
+}

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

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