pareto 0.61.0 → 0.62.0

package/auto.pareto/auto.dependencies/pareto-pure/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-pure/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-pure/glossaries/astn.data.ts

@@ -14,27 +14,29 @@ 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({
-            "Value": type(taggedUnion({
-                "verbose type": dictionary(ref(typeReference("Value"))),
-                "shorthand type": array(ref(typeReference("Value"))),
-                "dictionary": dictionary(ref(typeReference("Value"))),
-                "array": array(ref(typeReference("Value"))),
-                "quoted string": string(),
-                "apostrophed string": string(),
-                "backticked string": string(),
-                "raw string": string(),
-                "tagged union": group({
-                    "option": member(string()),
-                    "value": member(ref(typeReference("Value"))),
-                })
-            })),
+    'data glossary': {
+        'glossary parameters': d({
         }),
+        'imports': d({}),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Value": type(taggedUnion({
+                    "verbose type": dictionary(ref(typeReference("Value"))),
+                    "shorthand type": array(ref(typeReference("Value"))),
+                    "dictionary": dictionary(ref(typeReference("Value"))),
+                    "array": array(ref(typeReference("Value"))),
+                    "quoted string": string(),
+                    "apostrophed string": string(),
+                    "backticked string": string(),
+                    "raw string": string(),
+                    "tagged union": group({
+                        "option": member(string()),
+                        "value": member(ref(typeReference("Value"))),
+                    })
+                })),
+            }),
+        },
     },
     'interface types': d({
 

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.alan_light.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -436,6 +437,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.cosmos_type_system.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -1724,6 +1725,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.cosmos_typescript.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -117,6 +118,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.grammar.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({
         "Annotation": null,
@@ -257,6 +258,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.graphviz.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -663,6 +664,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

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

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -1449,6 +1450,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({
         "Annotation": null,
@@ -971,6 +972,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/auto.tendril_resolved.data.ts

@@ -6,6 +6,7 @@ const d = pd.d
 const a = pd.a
 
 export const $: g_cosmos.D.Glossary = {
+    'data glossary': {
     'imports': d({}),
     'glossary parameters': d({}),
     'root': {
@@ -857,6 +858,7 @@ export const $: g_cosmos.D.Glossary = {
             },
         }),
     },
+    },
     'interface types': d({}),
     'algorithm types': d({}),
 }

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/fountain_pen_directory.data.ts

@@ -18,24 +18,26 @@ import { $ as d_fountain_pen } from "./fountain_pen_indented_file.data"
 const d = pd.d
 
 export const $: g_glossary.D.Glossary = {
-    'glossary parameters': d({
-    }),
-    'imports': d({
-        "fp": imp(d_fountain_pen, {}),
-    }),
-    'root': {
-        'namespaces': d({}),
-        'data types': d({
-            "Directory": type(group({
-                "nodes": member(dictionary(taggedUnion({
-                    "allowed manual": null_(),
-                    "allowed automatic": null_(),
-                    "file": ref(externalTypeReference("fp", "Block")),
-                    "template": ref(externalTypeReference("fp", "Block")),
-                    "directory": ref(typeReference("Directory")),
-                })))
-            }))
+    'data glossary': {
+        'glossary parameters': d({
+        }),
+        'imports': d({
+            "fp": imp(d_fountain_pen, {}),
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Directory": type(group({
+                    "nodes": member(dictionary(taggedUnion({
+                        "allowed manual": null_(),
+                        "allowed automatic": null_(),
+                        "file": ref(externalTypeReference("fp", "Block")),
+                        "template": ref(externalTypeReference("fp", "Block")),
+                        "directory": ref(typeReference("Directory")),
+                    })))
+                }))
+            }),
+        },
     },
     'interface types': d({
 

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file.data.ts

@@ -11,35 +11,37 @@ 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({
-            "Block": type(array(taggedUnion({
-                "nested line": ref(typeReference("Line")),
-                "line": string(),
-                /**
-                 * this one can be used to make code generation easier.
-                 * it will be inlined
-                 */
-                "sub block": ref(typeReference("Block")),
-            }))),
-            "Line": type(array(taggedUnion({
-                "snippet": string(),
-                "indent": ref(typeReference("Block")),
-                /**
-                 * this one can be used to make code generation easier.
-                 * it will be inlined
-                 */
-                "sub line": ref(typeReference("Line")),
-            }))),
-            "Lines": type(array(group({
-                "indentation": member(number()),
-                "text": member(string()),
-            }))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Block": type(array(taggedUnion({
+                    "nested line": ref(typeReference("Line")),
+                    "line": string(),
+                    /**
+                     * this one can be used to make code generation easier.
+                     * it will be inlined
+                     */
+                    "sub block": ref(typeReference("Block")),
+                }))),
+                "Line": type(array(taggedUnion({
+                    "snippet": string(),
+                    "indent": ref(typeReference("Block")),
+                    /**
+                     * this one can be used to make code generation easier.
+                     * it will be inlined
+                     */
+                    "sub line": ref(typeReference("Line")),
+                }))),
+                "Lines": type(array(group({
+                    "indentation": member(number()),
+                    "text": member(string()),
+                }))),
+            }),
+        },
     },
     'interface types': d({
     }),

package/auto.pareto/auto.dependencies/pareto-pure/glossaries/fountain_pen_indented_file_with_escaped_strings.data.ts

@@ -11,28 +11,30 @@ 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({
-            "Block": type(array(taggedUnion({
-                "nested line": ref(typeReference("Line")),
-                "line": string(),
-            }))),
-            "Line": type(array(taggedUnion({
-                "snippet": string(),
-                "apostrophed string": string(),
-                "quoted string": string(),
-                "backticked string": string(),
-                "indent": ref(typeReference("Block"))
-            }))),
-            "Lines": type(array(group({
-                "indentation": member(number()),
-                "text": member(string()),
-            }))),
+    'data glossary': {
+        'glossary parameters': d({}),
+        'imports': d({
         }),
+        'root': {
+            'namespaces': d({}),
+            'data types': d({
+                "Block": type(array(taggedUnion({
+                    "nested line": ref(typeReference("Line")),
+                    "line": string(),
+                }))),
+                "Line": type(array(taggedUnion({
+                    "snippet": string(),
+                    "apostrophed string": string(),
+                    "quoted string": string(),
+                    "backticked string": string(),
+                    "indent": ref(typeReference("Block"))
+                }))),
+                "Lines": type(array(group({
+                    "indentation": member(number()),
+                    "text": member(string()),
+                }))),
+            }),
+        },
     },
     'interface types': d({}),
     'algorithm types': d({

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