pareto 0.64.0 → 0.65.0

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

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

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

@@ -1,12 +1,33 @@
 import * as pd from 'pareto-core-data'
 
 import {
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
+
+    aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, dictionary, ref, typeParameter, group, sInf, member,
-    sfunction,
-    sInterfaceMethod, sInterfaceReference, streamconsumer, string, taggedUnion, type, typeReference, aInterface, sInterface, parametrizedType,
-    infInit
+    infInit,
+    sInterface,
+    sInterfaceMethod,
+    streamconsumer,
+
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
@@ -20,33 +41,33 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Simple Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Simple Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
 
-                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-                "Simple String": type(string()),
+                "Simple Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
+                "Simple String": type(text()),
 
                 "Array": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "array": member(array(ref(typeParameter("Type")))),
-                    "end": member(ref(typeParameter("EndType"))),
+                    "array": member(list(component(typeParameter("Type")))),
+                    "end": member(component(typeParameter("EndType"))),
                 })),
                 "Dictionary": parametrizedType({ "Type": null, "EndType": null }, group({
-                    "dictionary": member(dictionary(ref(typeParameter("Type")))),
-                    "end": member(ref(typeParameter("EndType"))),
+                    "dictionary": member(dictionary(component(typeParameter("Type")))),
+                    "end": member(component(typeParameter("EndType"))),
                 })),
                 "String": parametrizedType({ "EndType": null }, group({
-                    "string": member(string()),
-                    "end": member(ref(typeParameter("EndType"))),
+                    "string": member(text()),
+                    "end": member(component(typeParameter("EndType"))),
                 })),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(string()),
-                    "value": member(ref(typeParameter("Type"))),
+                    "key": member(text()),
+                    "value": member(component(typeParameter("Type"))),
                 })),
 
-                "DictionaryBuildStrategy": type(taggedUnion({
+                "DictionaryBuildStrategy": type(stateGroup({
                     "ignore": group({}),
                     "overwrite": group({}),
                 })),
-                "Startstring": type(string()),
+                // "Startstring": type(text()),
             }),
         },
 

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

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

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

@@ -1,25 +1,24 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    dictionary,
-    typeReference,
+    boolean,
+    component,
     data,
-    sfunction,
-    ref,
-    typeParameter,
+    dictionary,
     externalTypeReference,
-    parametrizedType,
-    optional,
     group,
+    integer,
+    list,
     member,
-    aInterface,
-    streamconsumer,
-    aInterfaceMethod,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
     type,
-    string,
-    boolean,
-    sInterface,
-    sInterfaceMethod,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
@@ -34,42 +33,42 @@ export const $: g_glossary.D.Glossary = {
             'namespaces': d({}),
             'data types': d({
                 "Boolean": type(boolean()),
-                "String": type(string()),
+                "String": type(text()),
                 "KeyValuePair": parametrizedType({ "Type": null }, group({
-                    "key": member(string()),
-                    "value": member(ref(typeParameter("Type"))),
+                    "key": member(text()),
+                    "value": member(component(typeParameter("Type"))),
                 })),
-                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-                "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(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": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "primary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "secondary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
                 })),
                 "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                    "benchmark": member(ref(typeParameter("Benchmark"))),
-                    "focus": member(optional(ref(typeParameter("Focus")))),
+                    "benchmark": member(component(typeParameter("Benchmark"))),
+                    "focus": member(optional(component(typeParameter("Focus")))),
                 }))),
 
                 "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
-                    "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
-                    "focus": member(ref(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
+                    "benchmark": member(component(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                    "focus": member(component(typeReference("Dictionary", { "Type": typeParameter("Focus") }))),
                 })),
                 "FlattenDictionaryOfDictionariesParameters": parametrizedType({ "Type": null }, group({
-                    "dictionaries": member(dictionary(ref(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
-                    "separator": member(string()),
-                    "escape": member(string()),// to escape if the separator appears in the key of the top level dictionary
+                    "dictionaries": member(dictionary(component(typeReference("Dictionary", { "Type": typeParameter("Type") })))),
+                    "separator": member(text()),
+                    "escape": member(text()),// to escape if the separator appears in the key of the top level dictionary
                 })),
                 "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+                    "dictionary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "keyValuePair": member(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
                 })),
-                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(component(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
                 "WrapKeysData": parametrizedType({ "Type": null }, group({
-                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                    "prefix": member(string()),
-                    "suffix": member(string()),
+                    "dictionary": member(component(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "prefix": member(text()),
+                    "suffix": member(text()),
                 })),
             }),
         },

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

@@ -5,17 +5,16 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "add": algorithm("Add", null, {}),
-        "increment": algorithm("Increment", "IncrementConfig", {}),
-        "min": algorithm("Min", null, {}),
-        "max": algorithm("Max", null, {}),
-        "multiply": algorithm("Multiply", null, {}),
-        "negate": algorithm("Negate", null, {}),
-        "subtract": algorithm("Subtract", null, {}),
+        "add": algorithm("Add", {}),
+        "increment": algorithm("Increment", {}),
+        "min": algorithm("Min", {}),
+        "max": algorithm("Max", {}),
+        "multiply": algorithm("Multiply", {}),
+        "negate": algorithm("Negate", {}),
+        "subtract": algorithm("Subtract", {}),
     }
 )

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

@@ -1,8 +1,24 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
-    type, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
@@ -17,22 +33,22 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "Number": type(number()),
-                "OptionalNumber": type(optional(number())),
-                "NumberRange": type(array(number())),
+                "Number": type(integer()),
+                "OptionalNumber": type(optional(integer())),
+                "NumberRange": type(list(integer())),
                 "NumberTuple": type(group({
-                    "yin": member(number()),
-                    "yang": member(number()),
+                    "yin": member(integer()),
+                    "yang": member(integer()),
                 })),
                 "SubtractData": type(group({
-                    "minuend": member(number()),
-                    "subtrahend": member(number()),
+                    "minuend": member(integer()),
+                    "subtrahend": member(integer()),
                 })),
-                "NumberDictionary": type(dictionary(number())),
-                "NumberArray": type(array(number())),
+                "NumberDictionary": type(dictionary(integer())),
+                "NumberArray": type(list(integer())),
 
                 "IncrementConfig": type(group({
-                    "stepsize": member(number())
+                    "stepsize": member(integer())
                 }))
             }),
         },

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

@@ -5,12 +5,11 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "divide": algorithm("Divide", null, {}),
-        "divisionRemainder": algorithm("DivisionRemainder", null, {}),
+        "divide": algorithm("Divide", {}),
+        "divisionRemainder": algorithm("DivisionRemainder", {}),
     }
 )

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

@@ -1,10 +1,25 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
-    type, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
-
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 const d = pd.d
@@ -17,10 +32,10 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "OptionalNumber": type(optional(number())),
+                "OptionalNumber": type(optional(integer())),
                 "DivisionData": type(group({
-                    "numerator": member(number()),
-                    "denominator": member(number()),
+                    "numerator": member(integer()),
+                    "denominator": member(integer()),
                 })),
             }),
         },

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

@@ -5,7 +5,6 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, sInterface, sInterfaceMethod, string, type, typeReference } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,

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

@@ -1,22 +1,24 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    string, member, group,
-    typeReference,
+    boolean,
+    component,
     data,
-    sfunction,
-    type,
+    dictionary,
     externalTypeReference,
-    boolean,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
     parametrizedType,
-    dictionary,
-    ref,
+    sfunction,
+    stateGroup,
+    text,
+    type,
     typeParameter,
-    array,
-    null_,
-    computed,
-    sInterface,
-    sInterfaceMethod,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"

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

@@ -5,25 +5,24 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, group, member, number, type } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 export const $: g_project.D.API = api(
     glos,
     {
-        "join 2 strings": algorithm("Join 2 Strings", null, {}),
-        "join array of strings": algorithm("Join Array Of Strings", null, {}),
-        "repeat": algorithm("Repeat", null, {}),
+        "join 2 strings": algorithm("Join 2 Strings", {}),
+        "join array of strings": algorithm("Join Array Of Strings", {}),
+        "repeat": algorithm("Repeat", {}),
 
         /**
          * this functon joins an array of strings into a single string, using a separator, and optionally a maximum number of elements to join
          */
-        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
+        "getArrayAsString": algorithm("GetArrayAsString", {}),
 
-        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
+        "getLengthAsString": algorithm("GetLengthAsString", {}),
         
         //this one implicitely sorts the keys
         //"getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
 
-        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
+        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", {}),
     }
 )

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

@@ -1,11 +1,24 @@
 import * as pd from 'pareto-core-data'
 
 import {
-    aInterface,
-    aInterfaceMethod,
-    aInterfaceReference,
-    array, boolean,
-    data, dictionary, group, member, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, type, typeParameter, typeReference
+    boolean,
+    component,
+    data,
+    dictionary,
+    externalTypeReference,
+    group,
+    integer,
+    list,
+    member,
+    nothing,
+    optional,
+    parametrizedType,
+    sfunction,
+    stateGroup,
+    text,
+    type,
+    typeParameter,
+    typeReference,
 } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 
 import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
@@ -20,35 +33,39 @@ export const $: g_glossary.D.Glossary = {
         'root': {
             'namespaces': d({}),
             'data types': d({
-                "String": type(string()),
+                "String": type(text()),
                 "Join 2 Strings": type(group({
-                    "first": member(string()),
-                    "second": member(string()),
+                    "first": member(text()),
+                    "second": member(text()),
                 })),
                 "Join Array Of Strings": parametrizedType(
                     { "Type": null },
                     group({
-                        "array": member(array(ref(typeParameter("Type")))),
-                        "separator": member(string()),
+                        "array": member(list(component(typeParameter("Type")))),
+                        "separator": member(text()),
                     })
                 ),
 
                 "RepeatData": type(group({
-                    "contextString": member(string()),
-                    "times": member(number()),
+                    "contextString": member(text()),
+                    "times": member(integer()),
                 })),
 
-                "StringArray": type(array(string())),
+                "StringArray": type(list(text())),
+                "GetArrayAsString": type(group({
+                    "array": member(component(typeReference("StringArray"))),
+                    "configuration": member(component(typeReference("Configuration"))),
+                })),
 
                 "Configuration": type(group({
-                    "separator": member(string()),
+                    "separator": member(text()),
                     "maximum": member(optional(group({
-                        "maximum": member(number()),
-                        "suffix": member(string()),
+                        "maximum": member(integer()),
+                        "suffix": member(text()),
                     }))),
                 })),
-                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(component(typeParameter("Type")))),
+                "Array": parametrizedType({ "Type": null }, list(component(typeParameter("Type")))),
 
             }),
         },
@@ -75,7 +92,7 @@ export const $: g_glossary.D.Glossary = {
         ),
         "GetArrayAsString": sfunction(
             typeReference("String"),
-            data(typeReference("StringArray"))),
+            data(typeReference("GetArrayAsString"))),
         "GetKeysAsString": sfunction(
             typeReference("String"),
             data(typeReference("Dictionary", { "T": typeParameter("T") })),

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

@@ -5,7 +5,6 @@ import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/
 import * as g_project from "pareto-pure/auto.dist/public/auto.glossaries/auto.cosmos__type__system"
 
 import { $ as glos } from "./glossary.data"
-import { glossary, member, type, group, string, optional, number } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
 export const $: g_project.D.API = api(
     glos,
     {