pareto 0.61.0 → 0.62.0

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

@@ -13,40 +13,43 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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")))),
+    'data 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()),
+                "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"))),
-            })),
+                "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()),
+            }),
+        },
 
-            "DictionaryBuildStrategy": type(taggedUnion({
-                "ignore": group({}),
-                "overwrite": group({}),
-            })),
-            "Startstring": type(string()),
-        }),
     },
     'interface types': d({
         "Array": aInterface(

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

@@ -26,51 +26,53 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Boolean": type(boolean()),
-            "String": type(string()),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
-            "MergeParameters": parametrizedType({ "Type": null }, group({
-                "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-            })),
-            "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
-                "benchmark": member(ref(typeParameter("Benchmark"))),
-                "focus": member(optional(ref(typeParameter("Focus")))),
-            }))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Boolean": type(boolean()),
+                "String": type(string()),
+                "KeyValuePair": parametrizedType({ "Type": null }, group({
+                    "key": member(string()),
+                    "value": member(ref(typeParameter("Type"))),
+                })),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "FilterableDictionary": parametrizedType({ "Type": null }, dictionary(optional(ref(typeParameter("Type"))))),
+                "MergeParameters": parametrizedType({ "Type": null }, group({
+                    "primary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "secondary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                })),
+                "ZippedDictionary": parametrizedType({ "Benchmark": null, "Focus": null }, dictionary(group({
+                    "benchmark": member(ref(typeParameter("Benchmark"))),
+                    "focus": member(optional(ref(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") }))),
-            })),
-            "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
-            })),
-            "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
-                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
-                "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
-            })),
-            "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "DictionaryTuple": parametrizedType({ "Benchmark": null, "Focus": null }, group({
+                    "benchmark": member(ref(typeReference("Dictionary", { "Type": typeParameter("Benchmark") }))),
+                    "focus": member(ref(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
+                })),
+                "UnsafeAddEntryParameters": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                    "keyValuePair": member(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))
+                })),
+                "KeyValueDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
 
-            "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "WrapKeysData": parametrizedType({ "Type": null }, group({
-                "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
+                "RekeyDictionary": parametrizedType({ "Type": null }, dictionary(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
+                "WrapKeysData": parametrizedType({ "Type": null }, group({
+                    "dictionary": member(ref(typeReference("Dictionary", { "Type": typeParameter("Type") }))),
                     "prefix": member(string()),
                     "suffix": member(string()),
-            })),
-        }),
+                })),
+            }),
+        },
     },
     'interface types': d({
     }),

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

@@ -8,14 +8,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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"))))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -10,30 +10,32 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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())),
-            "NumberTuple": type(group({
-                "yin": member(number()),
-                "yang": 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())
-            }))
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Number": type(number()),
+                "OptionalNumber": type(optional(number())),
+                "NumberRange": type(array(number())),
+                "NumberTuple": type(group({
+                    "yin": member(number()),
+                    "yang": 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({
@@ -46,7 +48,7 @@ export const $: g_glossary.D.Glossary = {
         * if the denominator is 0, the return value is not set
         * (division by 0),
         */
-     
+
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */

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

@@ -10,18 +10,20 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "OptionalNumber": type(optional(number())),
-            "DivisionData": type(group({
-                "numerator": member(number()),
-                "denominator": member(number()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "OptionalNumber": type(optional(number())),
+                "DivisionData": type(group({
+                    "numerator": member(number()),
+                    "denominator": member(number()),
+                })),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({
@@ -32,5 +34,5 @@ export const $: g_glossary.D.Glossary = {
         "Divide": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
         "DivisionRemainder": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
     }),
-     
+
 }

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

@@ -23,14 +23,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -13,43 +13,45 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "String": type(string()),
-            "Join 2 Strings": type(group({
-                "first": member(string()),
-                "second": member(string()),
-            })),
-            "Join Array Of Strings": parametrizedType(
-                { "Type": null },
-                group({
-                    "array": member(array(ref(typeParameter("Type")))),
-                    "separator": member(string()),
-                })
-            ),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+        }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Join 2 Strings": type(group({
+                    "first": member(string()),
+                    "second": member(string()),
+                })),
+                "Join Array Of Strings": parametrizedType(
+                    { "Type": null },
+                    group({
+                        "array": member(array(ref(typeParameter("Type")))),
+                        "separator": member(string()),
+                    })
+                ),
 
-            "RepeatData": type(group({
-                "contextString": member(string()),
-                "times": member(number()),
-            })),
+                "RepeatData": type(group({
+                    "contextString": member(string()),
+                    "times": member(number()),
+                })),
 
-            "StringArray": type(array(string())),
+                "StringArray": type(array(string())),
 
-            "Configuration": type(group({
-                "separator": member(string()),
-                "maximum": member(optional(group({
-                    "maximum": member(number()),
-                    "suffix": member(string()),
-                }))),
-            })),
-            "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
-            "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
+                "Configuration": type(group({
+                    "separator": member(string()),
+                    "maximum": member(optional(group({
+                        "maximum": member(number()),
+                        "suffix": member(string()),
+                    }))),
+                })),
+                "Dictionary": parametrizedType({ "Type": null }, dictionary(ref(typeParameter("Type")))),
+                "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type")))),
 
-        }),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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

@@ -11,16 +11,18 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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")))),
-            "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "String": type(string()),
+                "Array": parametrizedType({ "T": null }, array(ref(typeParameter("T")))),
+                "Dictionary": parametrizedType({ "T": null }, dictionary(ref(typeParameter("T")))),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

package/auto.pareto/auto.dependencies/pareto-subatomic-library/glossaries/lines.data.ts

@@ -11,14 +11,16 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Lines": type(array(string())),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Lines": type(array(string())),
+            }),
+        },
     },
     'interface types': d({
     }),

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

@@ -11,30 +11,32 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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"))),
-            
-
+    'data 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({

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

@@ -27,24 +27,26 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 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"))),
-
+    'data 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({
     }),
@@ -66,7 +68,7 @@ export const $: g_glossary.D.Glossary = {
             { "Type": null }
         ),
 
-        "Size": sfunction(    
+        "Size": sfunction(
             typeReference("Number"),
             data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
             { "Type": null }

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

@@ -27,23 +27,25 @@ import * as g_glossary from "pareto-pure/auto.dist/public/auto.glossaries/auto.c
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({}),
-    'imports': d({
-        "lines": imp(d_lines, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "File Path": type(array(string())),
-            "File Write Data": type(group({
-                "directory path": member(ref(typeReference("File Path"))),
-                "file name": member(string()),
-                "data": member(ref(externalTypeReference("lines", "Lines"))),
-            })),
-            "Root Data": type(group({
-                "context directory": member(string()),
-            })),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
+            "lines": imp(d_lines, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "File Path": type(array(string())),
+                "File Write Data": type(group({
+                    "directory path": member(ref(typeReference("File Path"))),
+                    "file name": member(string()),
+                    "data": member(ref(externalTypeReference("lines", "Lines"))),
+                })),
+                "Root Data": type(group({
+                    "context directory": member(string()),
+                })),
+            }),
+        },
     },
     'interface types': d({
         "RootFileWriter": aInterface(aInterfaceMethod(typeReference("Root Data"), infref(aInterfaceReference("FileWriter")))),