pareto 0.75.2 → 0.76.1

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

@@ -1,37 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "flattenArrayOfArrays": algorithm([
-            `flatten an array of arrays`,
-        ], "FlattenArrayOfArrays", {}),
-        "append": algorithm([
-            `append an element to the end of an array`,
-        ], "Append", {}),
-        "prepend": algorithm([
-            `prepend an element to the beginning of an array`
-        ], "Prepend", {}),
-        "zip": algorithm([
-            `zip two arrays together`,
-            `the length of the resulting array is the length of the shortest input array`
-        ], "Zip", {}),
-        "flattenTree": algorithm([
-            `flatten a tree of values`,
-            `every node can be either an array, nothing or a value`
-        ], "FlattenTree", {}),
-        "unsafeSortTopologically": algorithm([
-            `sort a dictionary topologically`,
-            `the dictionary entries contains a value and a dictionary without values (only keys) that represent the dependencies`,
-            `if a circular dependency is detected, a panic is thrown`,
-            `the result is an array of key/value pairs`
-        ], "SortTopologically", {}),
-
-    }
-)

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

@@ -1,137 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                //out
-                "Array": parametrizedType(
-                    { "Type": null },
-                    list(component(typeParameter("Type")))
-                ),
-
-                "ZippedArray": parametrizedType(
-                    { "Benchmark": null, "Focus": null },
-                    list(group({
-                        "benchmark": prop(component(typeParameter("Benchmark"))),
-                        "focus": prop(component(typeParameter("Focus"))),
-                    }))
-                ),
-
-                //in
-                "ArrayOfArrays": parametrizedType(
-                    { "Type": null },
-                    list(component(typeReference("Array", { "Type": typeParameter("Type") })))),
-
-                "AppendParameters": parametrizedType(
-                    { "Type": null },
-                    group({
-                        "array": prop(component(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": prop(component(typeParameter("Type"))),
-                    })
-                ),
-                "PrependParameters": parametrizedType(
-                    { "Type": null },
-                    group({
-                        "array": prop(component(typeReference("Array", { "Type": typeParameter("Type") }))),
-                        "element": prop(component(typeParameter("Type"))),
-                    })
-                ),
-                "ArrayTuple": parametrizedType(
-                    { "Benchmark": null, "Focus": null },
-                    group({
-                        "benchmark": prop(component(typeReference("Array", { "Type": typeParameter("Benchmark") }))),
-                        "focus": prop(component(typeReference("Array", { "Type": typeParameter("Focus") }))),
-                    })
-                ),
-                "Nested": parametrizedType({ "Type": null }, stateGroup({
-                    "single": component(typeParameter("Type")),
-                    "multiple": list(component(typeReference("Nested", { "Type": typeParameter("Type") }))),
-                    "none": nothing(),
-                })),
-                // "Array": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-                // "KeyValuePair": parametrizedType({ "Type": null }, group({
-                //     "key": prop(text()),
-                //     "value": prop(component(typeParameter("Type"))),
-                // })),
-
-                "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                    "value": prop(component(typeParameter("Type"))),
-                    "dependencies": prop(dictionary(nothing())),
-                }))),
-
-
-                "KeyValuePairArray": parametrizedType({ "Type": null }, list(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-                "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": prop(text()),
-                    "value": prop(component(typeParameter("Type"))),
-                })),
-
-            }),
-        },
-    },
-    'interface types': d({}),
-    'algorithm types': d({
-        "Append": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("AppendParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "Prepend": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("PrependParameters", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "FlattenArrayOfArrays": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("ArrayOfArrays", { "Type": typeParameter("Type") })),
-            { "Type": null },
-        ),
-        "FlattenTree": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("Nested", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-        "Zip": sfunction(
-            typeReference("ZippedArray", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") }),
-            data(typeReference("ArrayTuple", { "Benchmark": typeParameter("Benchmark"), "Focus": typeParameter("Focus") })),
-            { "Benchmark": null, "Focus": null }
-        ),
-
-
-        "SortTopologically": sfunction(
-            typeReference("KeyValuePairArray", { "Type": typeParameter("Type") }),
-            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-    }),
-}

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

@@ -1,34 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "array and": algorithm([
-            `return true if all input values are true, false otherwise`,
-        ], "Array And", {}),
-        "array or": algorithm([
-            `return true if at least one of the input values is true, false otherwise`,
-        ], "Array Or", {}),
-        "array xor": algorithm([
-            `return true if an odd number of input values is true, false otherwise`,
-        ], "Array Xor", {}),
-        "and": algorithm([
-            `return true if both input values are true, false otherwise`,
-        ], "And", {}),
-        "or": algorithm([
-            `return true if at least one of the input values is true, false otherwise`,
-        ], "Or", {}),
-        "xor": algorithm([
-            `return true if exactly one of the input values is true, false otherwise`,
-        ], "Xor", {}),
-        "not": algorithm([
-            `return true if the input value is false, false otherwise`,
-        ], "Not", {}),
-    }
-)

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

@@ -1,55 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Boolean": type(boolean()),
-                "Pair Of Booleans": type(group({
-                    "yin": prop(boolean()),
-                    "yang": prop(boolean()),
-                })),
-                "Array Of Booleans": type(list(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/buildInterfaceInitializers/api.data.ts

@@ -1,22 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        // "buildArray": algorithm("BuildArray", {}),
-        // "buildUnsafeDictionary": algorithm("BuildUnsafeDictionary", {}),
-        // "buildSafeDictionary": algorithm("BuildSafeDictionary", "DictionaryBuildStrategy", {}, {
-        // }),
-        "createUnsafeDictionaryBuilder": algorithm([], "CreateUnsafeDictionaryBuilder", {}),
-        //"createSafeDictionaryBuilder": algorithm("CreateSafeDictionaryBuilder", {}),
-        "createArrayBuilder": algorithm([], "CreateArrayBuilder", {}),
-
-        "createStringBuilder": algorithm([], "CreateStringBuilder", {}),
-    }
-)

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

@@ -1,191 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    infInit,
-    sInterface,
-    sInterfaceMethod,
-    streamconsumer,
-
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Simple Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
-
-                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
-                "Simple String": type(text()),
-
-                "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "array": prop(list(component(typeParameter("Type")))),
-                    "end": prop(component(typeParameter("EndType"))),
-                })),
-                "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "dictionary": prop(dictionary(component(typeParameter("Type")))),
-                    "end": prop(component(typeParameter("EndType"))),
-                })),
-                "String": parametrizedType({ "EndType": null }, group({
-                    "string": prop(text()),
-                    "end": prop(component(typeParameter("EndType"))),
-                })),
-                "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": prop(text()),
-                    "value": prop(component(typeParameter("Type"))),
-                })),
-
-                "DictionaryBuildStrategy": type(stateGroup({
-                    "ignore": group({}),
-                    "overwrite": group({}),
-                })),
-                // "Startstring": type(text()),
-            }),
-        },
-
-    },
-    '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

@@ -1,58 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-
-import { $ as glos } from "./glossary.data"
-
-export const $: g_project.D.API = api(
-    glos,
-    {
-        "decorateDictionaryEntriesWithKey": algorithm([
-            `all dictionary entries are decorated with the key of the entry`,
-            `the key is added to the value of the entry`,
-        ], "DecorateDictionaryEntriesWithKey", {}),
-
-        "filter": algorithm([
-            `a dictionary of optional values is filtered into a regular dictionary`,
-            `if the optional value is not set, the entry is not included in the result`,
-            `if the optional value is set, the entry is included in the result`,
-        ], "Filter", {}),
-        "flattenDictionaryOfDictionaries": algorithm([
-            `flatten a dictionary of dictionaries`,
-            `the keys of the outermost dictionary is combined with the key of the innermost dictionary`,
-            `a separator is added between the keys`,
-            `if the separator appears in the keys of the outermost dictionary, it is escaped to guarantee uniqueness`,
-        ], "FlattenDictionaryOfDictionaries", {}),
-        "mergeAndOverwrite": algorithm([
-            `2 dictionaries are combined into 1 dictionary`,
-            `is a key exists in both directories, only the entry of the secondary dictionary will be used`,
-        ], "MergeAndOverwrite", {}),
-        "mergeAndIgnore": algorithm([
-            `2 dictionaries are combined into 1 dictionary`,
-            `is a key exists in both directories, only the entry of the primary dictionary will be used`,
-        ], "MergeAndIgnore", {}),
-        "unsafeRekey": algorithm([
-            `a dictionary with containing entries with a value 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", {}),
-        "unsafeMerge": algorithm([
-            `2 dictionaries are combined into 1 dictionary`,
-            `if a key exists in both directories, the function panics`,
-        ], "UnsafeMerge", {}),
-        "unsafeAddEntry": algorithm([
-            `a key/value pair is added to a dictionary resulting in a new dictionary`,
-            `if the key is not unique the function panics`,
-        ], "UnsafeAddEntry", {}),
-        "wrapKeys": algorithm([
-            `prepends and appends strings to all keys in the dictionary`,
-        ], "WrapKeys", {}),
-        "zip": algorithm([
-            `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", {}),
-    }
-)

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

@@ -1,132 +0,0 @@
-import * as pd from 'pareto-core-data'
-
-import {
-    boolean,
-    component,
-    data,
-    dictionary,
-    externalTypeReference,
-    group,
-    integer,
-    list,
-    prop,
-    nothing,
-    optional,
-    parametrizedType,
-    sfunction,
-    stateGroup,
-    text,
-    type,
-    typeParameter,
-    typeReference,
-} from "pareto-pure/auto.dist/public/shorthands/pareto_4gl_type_system.sh"
-
-import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.pareto_4gl_type_system"
-const d = pd.d
-
-export const $: g_glossary.D.Glossary = {
-    'data glossary': {
-        'glossary parameters': d({}),
-        'imports': d({
-        }),
-        'root': {
-            'namespaces': d({}),
-            'data types': d({
-                "Boolean": type(boolean()),
-                "String": type(text()),
-                "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": prop(text()),
-                    "value": prop(component(typeParameter("Type"))),
-                })),
-                "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
-                "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(component(typeParameter("Type"))))),
-                "MergeParameters": parametrizedType({ "Type": null }, group({
-                    "primary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "secondary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                })),
-                "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                    "benchmark": prop(component(typeParameter("Benchmark"))),
-                    "focus": prop(optional(component(typeParameter("Focus")))),
-                }))),
-
-                "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                    "benchmark": prop(component(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
-                    "focus": prop(component(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
-                })),
-                "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
-                    "dictionaries": prop(dictionary(component(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
-                    "separator": prop(text()),
-                    "escape": prop(text()),// to escape if the separator appears in the key of the top level dictionary
-                })),
-                "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                    "dictionary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "keyValuePair": prop(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
-                })),
-                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-
-                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-                "WrapKeysData": parametrizedType({ "Type": null }, group({
-                    "dictionary": prop(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "prefix": prop(text()),
-                    "suffix": prop(text()),
-                })),
-            }),
-        },
-    },
-    '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 }
-        ),
-        "WrapKeys": sfunction(
-            typeReference("Dictionary", { "Type": typeParameter("Type") }),
-            data(typeReference("WrapKeysData", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
-
-    }),
-
-}