pareto 0.56.0 → 0.57.0

package/auto.pareto/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-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, {}),
+
+    }
+)

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

@@ -0,0 +1,42 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, data, dictionary, typeReference, group, member, null_, number, optional, sfunction, string, type,
+    parametrizedType,
+    ref,
+    typeParameter
+} 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()),
+            "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
+            "StringArray": type(array(string())),
+            "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
+
+
+            "Configuration": type(group({
+                "separator": member(string()),
+                "maximum": member(optional(group({
+                    "maximum": member(number()),
+                    "suffix": member(string()),
+                }))),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "GetLengthAsString": sfunction(typeReference("String"), data(typeReference("Array", { "T": typeParameter("T") })), { "T": null}),
+        "GetArrayAsString": sfunction(typeReference("String"), data(typeReference("StringArray"))),
+        "GetKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
+        "GetNumberOfKeysAsString": sfunction(typeReference("String"), data(typeReference("Dictionary", { "T": typeParameter("T") })), { "T": null}),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/$.data.ts

@@ -0,0 +1,36 @@
+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_array } from "./modules/array/api.data"
+import { $ as d_dictionary } from "./modules/dictionary/api.data"
+import { $ as d_json } from "./modules/json/api.data"
+import { $ as d_numerical_predicates } from "./modules/numerical_predicates/api.data"
+import { $ as d_string } from "./modules/string/api.data"
+
+export const $: g_project.D.Library = {
+    'author': "Corno",
+    'description': "A library that contains common functionality that requires inspection of built in types, like the length of an array, patterns in a string, splitting strings, keys in dictionaries, etc.",
+    'license': "TBD",
+
+    'type': ['impure', null],
+    'module sets': {
+        'public': {
+            'glossaries': d({}),
+            'modules': d({
+                "array": d_array,
+                "dictionary": d_dictionary,
+                "json": d_json,
+                "numerical predicates": d_numerical_predicates,
+                "string": d_string,
+            })
+        },
+        'private': {
+            'glossaries': d({}),
+            'modules': d({}),
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+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,
+    {
+        "enrichWithPositionInformation": algorithm("EnrichWithPositionInformation", null, {}),
+        "getPossibleLastElement": algorithm("GetPossibleLastElement", null, {}),
+        "getPossibleFirstElement": algorithm("GetPossibleFirstElement", null, {}),
+        "getPossibleElementAt": algorithm("GetPossibleElementAt", null, {}),
+        "isEmpty": algorithm("IsEmpty", null, {}),
+        "unsafeGetLastElement": algorithm("UnsafeGetLastElement", null, {}),
+        "unsafeGetFirstElement": algorithm("UnsafeGetFirstElement", null, {}),
+        "unsafeGetElementAt": algorithm("UnsafeGetElementAt", null, {}),
+        "getLength": algorithm("GetLength", null, {}),
+    }
+)

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

@@ -0,0 +1,88 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean,
+    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({
+            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+            "Boolean": type(boolean()),
+            "EnrichedArray": parametrizedType({ "Type": null }, array(group({
+                "value": member(ref(typeParameter("Type"))),
+                "isFirst": member(boolean()),
+                "isLast": member(boolean()),
+                "position": member(number()),
+            }))),
+            "GetElementAtData": parametrizedType({ "Type": null }, group({
+                "array": member(ref(typeReference("Array", { "Type": typeParameter("Type") }))),
+                "index": member(number()),
+            })),
+            "Length": type(number()),
+            "OptionalValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+            "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+            
+
+
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "EnrichWithPositionInformation": sfunction(
+            typeReference("EnrichedArray", { "Type": typeParameter("Type") }),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "GetPossibleElementAt": sfunction(
+            typeReference("OptionalValue", { "Type": typeParameter("Type") }),
+            data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "GetPossibleLastElement": sfunction(
+            typeReference("OptionalValue", { "Type": typeParameter("Type") }),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "GetPossibleFirstElement": sfunction(
+            typeReference("OptionalValue", { "Type": typeParameter("Type") }),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "GetLength": sfunction(
+            typeReference("Length"),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "IsEmpty": sfunction(
+            typeReference("Boolean"),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeGetElementAt": sfunction(
+            typeReference("Value", { "Type": typeParameter("Type") }),
+            data(typeReference("GetElementAtData", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeGetLastElement": sfunction(
+            typeReference("Value", { "Type": typeParameter("Type") }),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "UnsafeGetFirstElement": sfunction(
+            typeReference("Value", { "Type": typeParameter("Type") }),
+            data(typeReference("Array", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+    }),
+}

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

@@ -0,0 +1,27 @@
+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,
+    {
+        /**
+         * does the dictionary contain the specified key
+         */
+        "contains": algorithm("Contains", null, {}),
+        "getPossibleEntry": algorithm("GetPossibleEntry", null, {}),
+        /**
+         * is the dictionary empty (no entries)
+         */
+        "isEmpty": algorithm("IsEmpty", null, {}),
+
+        "size": algorithm("Size", null, {}),
+
+        "unsafeGetEntry": algorithm("UnsafeGetEntry", null, {}),
+    }
+)

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

@@ -0,0 +1,82 @@
+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,
+    number,
+} 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()),
+            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+            "DictionaryAndKey": parametrizedType({ "Type": null }, group({
+                "dictionary": member(dictionary(ref(typeParameter("Type")))),
+                "key": member(string()),
+            })),
+            
+            "Number": type(number()),
+            "PossibleValue": parametrizedType({ "Type": null }, optional(ref(typeParameter("Type")))),
+            "Value": parametrizedType({ "Type": null }, ref(typeParameter("Type"))),
+
+        }),
+    },
+    'interface types': d({
+    }),
+    'algorithm types': d({
+        "Contains": sfunction(
+            typeReference("Boolean"),
+            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+
+        "GetPossibleEntry": sfunction(
+            typeReference("PossibleValue", { "Type": typeParameter("Type") }),
+            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "IsEmpty": sfunction(
+            typeReference("Boolean"),
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+
+        "Size": sfunction(    
+            typeReference("Number"),
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+
+        "UnsafeGetEntry": sfunction(
+            typeReference("Value", { "Type": typeParameter("Type") }),
+            data(typeReference("DictionaryAndKey", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        )
+    }),
+
+}

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

@@ -0,0 +1,16 @@
+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,
+    {
+        "convertJSON": algorithm("ConvertJSON", null, {}),
+        "unsafeConvertJSON": algorithm("UnsafeConvertJSON", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-subatomic-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 "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({
+        "ConvertJSON": sfunction(typeReference("Result"), data(typeReference("String"))),
+
+        /*use this one if the application may crash if the JSON is invalid*/
+        "UnsafeConvertJSON": sfunction(typeReference("Value"), data(typeReference("String"))),
+        //"Convert": sfunction(typeReference("Result"), data(typeReference("Value"))),
+    }),
+}

package/auto.pareto/auto.dependencies/pareto-subatomic-library/modules/numerical_predicates/api.data.ts

@@ -0,0 +1,18 @@
+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,
+    {
+        "smallerThan": algorithm("SmallerThan", null, {}),
+        "greaterThan": algorithm("GreaterThan", null, {}),
+        "isZero": algorithm("IsZero", null, {}),
+        "equal": algorithm("Equal", null, {}),
+    }
+)

package/auto.pareto/auto.dependencies/pareto-subatomic-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 "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()),
+            "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-subatomic-library/modules/string/api.data.ts

@@ -0,0 +1,42 @@
+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,
+    {
+        "charCodeAt": algorithm("CharCodeAt", null, {}),
+        "endsWith": algorithm("EndsWith", null, {}),
+        "escape": algorithm("Escape", null, {}),
+        "fromCharacterArray": algorithm("FromCharacterArray", null, {}),
+        "fromCharacter": algorithm("FromCharacter", null, {}),
+        "includes": algorithm("Includes", null, {}),
+        "indexOf": algorithm("IndexOf", null, {}),
+        "length": algorithm("Length", null, {}),
+        "padEnd": algorithm("PadEnd", null, {}),
+        "padStart": algorithm("PadStart", null, {}),
+        "replaceAll": algorithm("ReplaceAll", null, {}),
+        "replaceFirst": algorithm("ReplaceFirst", null, {}),
+        "split": algorithm("Split", null, {}),
+        "splitIn2": algorithm("SplitIn2", null, {}),
+        "startsWith": algorithm("StartsWith", null, {}),
+        "substring": algorithm("Substring", null, {}),
+        "toCharacterArray": algorithm("ToCharacterArray", null, {}),
+        "unsafeCharCodeAt": algorithm("UnsafeCharCodeAt", null, {}),
+
+        "foobar": algorithm("Foobar", null, {}),
+
+        //candidates:
+
+        //"trimEnd": algorithm("TrimEnd", null, {}),
+        // lastIndexOf(searchValue[, fromIndex])
+        // Returns the last index of the specified value.
+
+
+    }
+)

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

@@ -0,0 +1,109 @@
+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()),
+            "Length": type(number()),
+            "Boolean": type(boolean()),
+            "Character Code": type(number()),
+            "Possible Character Code": type(optional(number())),
+            "Possible Position": type(optional(number())),
+
+            "CharacterCode At Data": type(group({
+                "contextString": member(string()),
+                "index": member(number()),
+            })),
+            "CharacterArray": type(array(number())),
+            "SplitData": type(group({
+                "contextString": member(string()),
+                "splitter": member(string()),
+            })),
+            "IncludesData": type(group({
+                "contextString": member(string()),
+                "searchString": 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()),
+            })),
+            "EndsWithData": type(group({
+                "contextString": member(string()),
+                "searchString": member(string()),
+            })),
+            "SubstringData": type(group({
+                "contextString": member(string()),
+                "begin": member(number()),
+                /**
+                 * I'm deliberately choosing length over end here, because length will become a 'natural' in the future
+                 * and then this function is guaranteed to not have a negative length.
+                 * going with 'end' would require a check for negative values.
+                 */
+                "length": member(number()),
+            })),
+            "ReplaceData": type(group({
+                "contextString": member(string()),
+                "pattern": member(string()),
+                "replacement": member(string()),
+            })),
+            "EscapeParameters": type(group({
+                "contextString": member(string()),
+                "escape": member(string()),
+                "patterns to escape": member(array(string())),
+            })),
+            "PadData": type(group({
+                "contextString": member(string()),
+                "targetLength": member(number()),
+                "padString": member(string()),
+            })),
+            "IndexOfData": type(group({
+                "contextString": member(string()),
+                "searchString": member(string()),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        "CharCodeAt": sfunction(typeReference("Possible Character Code"), data(typeReference("CharacterCode At Data"))),
+        "EndsWith": sfunction(typeReference("Boolean"), data(typeReference("EndsWithData"))),
+        "Escape": sfunction(typeReference("String"), data(typeReference("EscapeParameters"))),
+        "FromCharacter": sfunction(typeReference("String"), data(typeReference("Character Code"))),
+        "FromCharacterArray": sfunction(typeReference("String"), data(typeReference("CharacterArray"))),
+        "Includes": sfunction(typeReference("Boolean"), data(typeReference("IncludesData"))),
+        "IndexOf": sfunction(typeReference("Possible Position"), data(typeReference("IndexOfData"))),
+        "Length": sfunction(typeReference("Length"), data(typeReference("String"))),
+        "PadEnd": sfunction(typeReference("String"), data(typeReference("PadData"))),
+        "PadStart": sfunction(typeReference("String"), data(typeReference("PadData"))),
+        "ReplaceAll": sfunction(typeReference("String"), data(typeReference("ReplaceData"))),
+        "ReplaceFirst": sfunction(typeReference("String"), data(typeReference("ReplaceData"))),
+        "Split": sfunction(typeReference("SplitResult"), data(typeReference("SplitData"))),
+        "SplitIn2": sfunction(typeReference("SplitIn2Result"), data(typeReference("SplitData"))),
+        "StartsWith": sfunction(typeReference("Boolean"), data(typeReference("StartsWithData"))),
+        "Substring": sfunction(typeReference("String"), data(typeReference("SubstringData"))),
+        "ToCharacterArray": sfunction(typeReference("CharacterArray"), data(typeReference("String"))),
+        "UnsafeCharCodeAt": sfunction(typeReference("Character Code"), data(typeReference("CharacterCode At Data"))),
+        //"TrimEnd": sfunction(typeReference("String"), data(typeReference("String"))),
+
+        "Foobar": sfunction(typeReference("String"), data(typeReference("String"))),
+    }),
+}