pareto 0.55.0 → 0.57.0

package/auto.pareto/$.data.ts

@@ -1,22 +1,19 @@
 import * as pd from 'pareto-core-data'
 import * as pt from 'pareto-core-types'
 
-import * as g_project from "lib-pareto-typescript-project/dist/modules/cosmos_type_system"
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
 
 const d = pd.d
-import { } from "lib-pareto-typescript-project/dist/modules/cosmos_type_system/shorthands"
+import { } from "pareto/auto.dist/public/shorthands/cosmos"
 
-import { $ as d_cosmos_type_system } from "./glossaries/auto.cosmos_type_system.data"
-import { $ as d_pareto } from "./glossaries/auto.pareto.data"
 
-import { $ as d_fountain_pen } from "./modules/fountain_pen/api.data"
-import { $ as d_cosmos2pareto } from "./modules/cosmos2pareto/api.data"
 import { $ as d_pareto2typescript } from "./modules/pareto2typescript/api.data"
-
+import { $ as d_ts_naming } from "./modules/typescript_naming/api.data"
+import { $ as d_ts_serialize } from "./modules/typescript_serialize/api.data"
 
 import { $ as d_dependencies } from "./auto.dependencies"
 
-export const $: g_project.D.Library<pd.SourceLocation> = {
+export const $: g_project.D.Library = {
     'author': "Corno",
     'description': "",
     'license': "TBD",
@@ -27,13 +24,11 @@ export const $: g_project.D.Library<pd.SourceLocation> = {
     'module sets': {
         'public': {
             'glossaries': d({
-                "cosmos type system": d_cosmos_type_system,
-                "pareto": d_pareto,
             }),
             'modules': d({
-                "fountain pen": d_fountain_pen,
-                "cosmos 2 pareto": d_cosmos2pareto,
-                "pareto 2 typescript": d_pareto2typescript,
+                "pareto2typescript": d_pareto2typescript,
+                "typescript naming": d_ts_naming,
+                "typescript serialize": d_ts_serialize,
             }),
         },
         'private': {

package/auto.pareto/auto.dependencies/index.ts

@@ -1,9 +1,11 @@
 import * as pd from 'pareto-core-data'
 
-import { $ as dep_pareto_standard_impure_library } from './pareto-standard-impure-library/$.data'
-import { $ as dep_res_typescript } from './res-typescript/$.data'
+import { $ as dep_pareto_pure } from './pareto-pure/$.data'
+import { $ as dep_pareto_standard_library } from './pareto-standard-library/$.data'
+import { $ as dep_pareto_subatomic_library } from './pareto-subatomic-library/$.data'
 
 export const $ = pd.d({
-    'pareto-standard-impure-library': { library: dep_pareto_standard_impure_library, version: '^0.10.0' },
-    'res-typescript': { library: dep_res_typescript, version: '^0.36.0' },
+    'pareto-pure': { library: dep_pareto_pure, version: '^0.1.0' },
+    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.4.0' },
+    'pareto-subatomic-library': { library: dep_pareto_subatomic_library, version: '^0.3.0' },
 })

package/auto.pareto/auto.dependencies/pareto-pure/$.data.ts

@@ -0,0 +1,60 @@
+import * as pd from 'pareto-core-data'
+import * as pt from 'pareto-core-types'
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+import { } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_cosmos_type_system } from "./glossaries/auto.cosmos_type_system.data"
+import { $ as d_cosmos_typescript } from "./glossaries/auto.cosmos_typescript.data"
+import { $ as d_pareto } from "./glossaries/auto.pareto.data"
+import { $ as d_liana } from "./glossaries/auto.liana.data"
+import { $ as d_tendril } from "./glossaries/auto.tendril.data"
+import { $ as d_grammar } from "./glossaries/auto.grammar.data"
+import { $ as d_testresult } from "./modules/testresult/api.data"
+
+
+import { $ as d_fountain_pen } from "./modules/fountain_pen/api.data"
+import { $ as d_cosmos2pareto } from "./modules/cosmos2pareto/api.data"
+import { $ as d_liana2tendril } from "./modules/liana2tendril/api.data"
+import { $ as d_tendril2cosmos_type_system } from "./modules/tendril2cosmos_type_system/api.data"
+import { $ as d_tendril2pareto } from "./modules/tendril2pareto/api.data"
+
+
+import { $ as d_dependencies } from "./auto.dependencies"
+
+export const $: g_project.D.Library = {
+    'author': "Corno",
+    'description': "",
+    'license': "TBD",
+
+    'type': ['pure', {
+        'dependencies': d_dependencies,
+    }],
+    'module sets': {
+        'public': {
+            'glossaries': d({
+                "cosmos type system": d_cosmos_type_system,
+                "cosmos typescript": d_cosmos_typescript,
+                "grammar": d_grammar,
+                "liana": d_liana,
+                "pareto": d_pareto,
+                "tendril": d_tendril,
+            }),
+            'modules': d({
+                "fountain pen": d_fountain_pen,
+                "cosmos 2 pareto": d_cosmos2pareto,
+                //"liana 2 tendril": d_liana2tendril,
+                "tendril 2 cosmos type system": d_tendril2cosmos_type_system,
+                "tendril 2 pareto": d_tendril2pareto,
+                "testresult": d_testresult,
+            }),
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({
+            }),
+        }
+    }
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/index.ts

@@ -0,0 +1,7 @@
+import * as pd from 'pareto-core-data'
+
+import { $ as dep_pareto_standard_library } from './pareto-standard-library/$.data'
+
+export const $ = pd.d({
+    'pareto-standard-library': { library: dep_pareto_standard_library, version: '^0.4.0' },
+})

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/$.data.ts

@@ -0,0 +1,58 @@
+import * as pd from 'pareto-core-data'
+
+import * as g_project from "pareto/auto.dist/public/glossaries/cosmos__type__system"
+
+const d = pd.d
+import { } from "pareto/auto.dist/public/shorthands/cosmos"
+
+import { $ as d_arithmetic } from "./modules/arithmetic/api.data"
+import { $ as d_array } from "./modules/array/api.data"
+import { $ as d_boolean } from "./modules/boolean/api.data"
+import { $ as d_build } from "./modules/build/api.data"
+import { $ as d_collation } from "./modules/collation/api.data"
+import { $ as d_dictionary } from "./modules/dictionary/api.data"
+import { $ as d_filesystem } from "./modules/filesystem/api.data"
+import { $ as d_foreach } from "./modules/foreach/api.data"
+import { $ as d_http } from "./modules/http/api.data"
+import { $ as d_json } from "./modules/json/api.data"
+import { $ as d_path } from "./modules/path/api.data"
+import { $ as d_nested } from "./modules/nested/api.data"
+import { $ as d_numerical_predicates } from "./modules/numerical_predicates/api.data"
+import { $ as d_resolve } from "./modules/resolve/api.data"
+import { $ as d_string } from "./modules/string/api.data"
+import { $ as d_tostring } from "./modules/tostring/api.data"
+
+export const $: g_project.D.Library = {
+    'author': "Corno",
+    'description': "A library that contains very common functionality that cannot be implemented purely in Pareto",
+    'license': "TBD",
+
+    'type': ['impure', null],
+    'module sets': {
+        'public': {
+            'glossaries': d({}),
+            'modules': d({
+                "arithmetic": d_arithmetic,
+                "array": d_array,
+                "boolean": d_boolean,
+                "build": d_build,
+                "collation": d_collation,
+                "dictionary": d_dictionary,
+                "filesystem": d_filesystem,
+                "foreach": d_foreach,
+                "http": d_http,
+                "json": d_json,
+                "nested": d_nested,
+                "numerical predicates": d_numerical_predicates,
+                "path": d_path,
+                "resolve": d_resolve,
+                "string": d_string,
+                "tostring": d_tostring,
+            })
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({}),
+        }
+    }
+}

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

@@ -0,0 +1,26 @@
+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,
+    {
+        "arrayMax": algorithm("ArrayMax", null, {}),
+        "arrayMin": algorithm("ArrayMin", null, {}),
+        "arraySum": algorithm("ArraySum", null, {}),
+        "dictionaryMax": algorithm("DictionaryMax", null, {}),
+        "dictionaryMin": algorithm("DictionaryMin", null, {}),
+        "dictionarySum": algorithm("DictionarySum", null, {}),
+        "divideWithRemainder": algorithm("DivideWithRemainder", null, {}),
+        "increment": algorithm("Increment", "IncrementConfig", {}),
+        "max": algorithm("Max", null, {}),
+        "array_multiply": algorithm("Array Multiply", null, {}),
+        "negate": algorithm("Negate", null, {}),
+        "subtract": algorithm("Subtract", null, {}),
+    }
+)

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

@@ -0,0 +1,76 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, 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({
+            "Number": type(number()),
+            "OptionalNumber": type(optional(number())),
+            "NumberRange": type(array(number())),
+            "DivisionData": type(group({
+                "numerator": member(number()),
+                "denominator": member(number()),
+            })),
+            "NumberTuple": type(group({
+                "yin": member(number()),
+                "yang": member(number()),
+            })),
+            "DivisionResult": type(optional(group({
+                "quotient": member(number()),
+                "remainder": member(number()),
+
+            }))),
+            "SubtractData": type(group({
+                "minuend": member(number()),
+                "subtrahend": member(number()),
+            })),
+            "NumberDictionary": type(dictionary(number())),
+            "NumberArray": type(array(number())),
+
+            "IncrementConfig": type(group({
+                "stepsize": member(number())
+            }))
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "Increment": sfunction(typeReference("Number"), data(typeReference("Number"))),
+        "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
+        "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
+        /**
+        * if the denominator is 0, the return value is null
+        * (division by 0),
+        */
+        "DivideWithRemainder": sfunction(typeReference("DivisionResult"), data(typeReference("DivisionData"))),
+        /**
+         * calculates the max of an array of numbers. If there are no entries, the result value is 0
+         */
+        "ArrayMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        "ArrayMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberArray"))),
+        "ArraySum": sfunction(typeReference("Number"), data(typeReference("NumberArray"))),
+        /**
+         * calculates the max of a dictionary of number. If there are no entries, the result value is 0
+         */
+        "DictionaryMax": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        "DictionaryMin": sfunction(typeReference("OptionalNumber"), data(typeReference("NumberDictionary"))),
+        /**
+        * calculates the max of a tuple of numbers
+        */
+        "DictionarySum": sfunction(typeReference("Number"), data(typeReference("NumberDictionary"))),
+
+        "Max": sfunction(typeReference("Number"), data(typeReference("NumberTuple"))),
+        "Subtract": sfunction(typeReference("Number"), data(typeReference("SubtractData"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-library/modules/array/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,
+    {
+        "getLastElement": algorithm("GetLastElement", null, {}),
+        //FIXME "getElementAt": algorithm("GetElementAt", null, {}),
+        "getLength": algorithm("GetLength", null, {}),
+        "flattenArrayOfArrays": algorithm("FlattenArrayOfArrays", null, {}),
+        "push": algorithm("Push", null, {}),
+        "matchArrays": algorithm("MatchArrays", null, {}),
+
+    }
+)

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

@@ -0,0 +1,60 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, externalTypeReference, group, member, number, optional, parametrizedType, ref, sfunction,
+    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({
+            "Length": type(number()),
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+            "ArrayOfArrays": parametrizedType({ "Type": null }, array(ref(typeReference("Array", { "Type": typeParameter("Type") })))),
+            "GetElementAtData": parametrizedType({ "Type": null }, group({
+                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                "index": member(number()),
+            })),
+            "PushParameters": parametrizedType({ "Type": null }, group({
+                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                "element": member(ref(typeParameter("Type"))),
+            })),
+            "OptionalElement": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+
+
+            "ArrayTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                "benchmark": member(ref(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
+                "focus": member(ref(typeReference("Array", { "Type": typeParameter("Focus") }))),
+            })),
+
+            "MatchedArrays": parametrizedType({ "Benchmark": null, "Focus": null }, array(group({
+                "benchmark": member(ref(typeParameter("Benchmark"))),
+                "focus": member(ref(typeParameter("Focus"))),
+            }))),
+
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "GetElementAt": sfunction(typeParameter("Type"), data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })), { "Type": null }),
+        "GetLastElement": sfunction(typeReference("OptionalElement", { "Type": typeParameter("Type") }), data(typeReference("Array", { "Type": typeParameter("Type") })), { "Type": null }),
+        "GetLength": sfunction(typeReference("Length"), data(typeReference("Array", { "Type": typeParameter("Type") })), { "Type": null }),
+        "FlattenArrayOfArrays": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })), { "Type": null }),
+        "Push": sfunction(typeReference("Array", { "Type": typeParameter("Type") }), data(typeReference("PushParameters", { "Type": typeParameter("Type") })), { "Type": null }),
+
+
+        "MatchArrays": sfunction(
+            typeReference("MatchedArrays", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
+            data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
+            { "Benchmark": null, "Focus": null }
+        ),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-impure-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-impure-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-impure-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-impure-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-impure-library/modules/collation/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,
+    {
+        "localeIsBefore": algorithm("IsBefore", null, {}),
+    }
+)