pareto 0.59.0 → 0.61.0

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

@@ -10,7 +10,21 @@ import { aInterface, aInterfaceMethod, glossary, group, member, number, sInterfa
 export const $: g_project.D.API = api(
     glos,
     {
+        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
+
         "filter": algorithm("Filter", null, {}),
+        /**
+         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
+         */
+        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
+        /**
+         * 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, {}),
+        /**
+         * 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, {}),
         /**
          * 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
@@ -26,24 +40,15 @@ export const $: g_project.D.API = api(
          * if the key is not unique the function panics
          */
         "unsafeAddEntry": algorithm("UnsafeAddEntry", null, {}),
+        /**
+         * prepends and appends strings to all keys in the dictionary
+         */
+        "wrapKeys": algorithm("WrapKeys", null, {}),
         /**
          * 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, {}),
-        /**
-         * 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, {}),
-        /**
-         * the keys of the outermost dictionary is combined with the key of the innermost dictionary
-         */
-        "flattenDictionaryOfDictionaries": algorithm("FlattenDictionaryOfDictionaries", null, {}),
-        /**
-         * 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, {}),
-        "decorateDictionaryEntriesWithKey": algorithm("DecorateDictionaryEntriesWithKey", null, {}),
     }
 )

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

@@ -65,7 +65,11 @@ export const $: g_glossary.D.Glossary = {
             "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") }))),
+                    "prefix": member(string()),
+                    "suffix": member(string()),
+            })),
         }),
     },
     'interface types': d({
@@ -110,8 +114,17 @@ export const $: g_glossary.D.Glossary = {
             typeReference("Dictionary", { "Type": typeParameter("Type") }),
             data(typeReference("MergeParameters", { "Type": typeParameter("Type") })),
             { "Type": null }
-        ),       
-         "DecorateDictionaryEntriesWithKey": sfunction(typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }), data(typeReference("Dictionary", { "Type": typeParameter("Type") })), { "Type": null }),
+        ),
+        "DecorateDictionaryEntriesWithKey": sfunction(
+            typeReference("KeyValueDictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("Dictionary", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
+        "WrapKeys": sfunction(
+            typeReference("Dictionary", { "Type": typeParameter("Type") }),
+            data(typeReference("WrapKeysData", { "Type": typeParameter("Type") })),
+            { "Type": null }
+        ),
 
     }),
 

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

@@ -10,6 +10,5 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "flatten": algorithm("Flatten", null, {})
     }
 )

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

@@ -14,16 +14,10 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Nested": parametrizedType({ "Type": null }, taggedUnion({
-                "single": ref(typeParameter("Type")),
-                "multiple": array(ref(typeReference("Nested", { "Type": typeParameter("Type")}))),
-                "none": null_(),
-            })),
             "Array": parametrizedType({ "Type": null }, array(ref(typeParameter("Type"))))
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "Flatten": sfunction(typeReference("Array", { "Type": typeParameter("Type")}), data(typeReference("Nested", { "Type": typeParameter("Type")})), { "Type": null })
     }),
 }

package/auto.pareto/auto.dependencies/{pareto-standard-library/modules/arithmetic → pareto-pure/auto.dependencies/pareto-standard-library/modules/number}/api.data.ts

@@ -11,7 +11,6 @@ export const $: g_project.D.API = api(
     glos,
     {
         "add": algorithm("Add", null, {}),
-        "divideWithRemainder": algorithm("DivideWithRemainder", null, {}),
         "increment": algorithm("Increment", "IncrementConfig", {}),
         "min": algorithm("Min", null, {}),
         "max": algorithm("Max", null, {}),

package/auto.pareto/auto.dependencies/pareto-pure/auto.dependencies/pareto-standard-library/modules/{arithmetic → number}/glossary.data.ts

@@ -19,19 +19,10 @@ export const $: g_glossary.D.Glossary = {
             "Number": type(number()),
             "OptionalNumber": type(optional(number())),
             "NumberRange": type(array(number())),
-            "DivisionData": type(group({
-                "numerator": member(number()),
-                "denominator": member(number()),
-            })),
             "NumberTuple": type(group({
                 "yin": member(number()),
                 "yang": member(number()),
             })),
-            "DivisionResult": type(optional(group({
-                "quotient": member(number()),
-                "remainder": member(number()),
-
-            }))),
             "SubtractData": type(group({
                 "minuend": member(number()),
                 "subtrahend": member(number()),
@@ -52,10 +43,10 @@ export const $: g_glossary.D.Glossary = {
         // "Array Multiply": sfunction(typeReference("Number"), data(typeReference("NumberRange"))),
         "Negate": sfunction(typeReference("Number"), data(typeReference("Number"))),
         /**
-        * if the denominator is 0, the return value is null
+        * if the denominator is 0, the return value is not set
         * (division by 0),
         */
-        "DivideWithRemainder": sfunction(typeReference("DivisionResult"), data(typeReference("DivisionData"))),
+     
         /**
          * calculates the max of an array of numbers. If there are no entries, the result value is 0
          */

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

@@ -0,0 +1,16 @@
+import * as pd from 'pareto-core-data'
+
+import { algorithm, algref, api } from "pareto-pure/auto.dist/public/shorthands/cosmos_type_system.sh"
+
+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, {}),
+    }
+)

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

@@ -0,0 +1,36 @@
+import * as pd from 'pareto-core-data'
+
+import {
+    array, boolean, data, dictionary, externalTypeReference, group, member, number, optional, sfunction,
+    type, 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
+
+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()),
+            })),
+        }),
+    },
+    'interface types': d({}),
+    'algorithm types': d({
+        /**
+        * if the denominator is 0, the return value is not set
+        * (division by 0),
+        */
+        "Divide": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
+        "DivisionRemainder": sfunction(typeReference("OptionalNumber"), data(typeReference("DivisionData"))),
+    }),
+     
+}

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

@@ -10,6 +10,5 @@ import { glossary, group, member, number, sInterface, sInterfaceMethod, string,
 export const $: g_project.D.API = api(
     glos,
     {
-        "unsafeSortTopologically": algorithm("SortTopologically", null, {}),
     }
 )

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

@@ -29,24 +29,10 @@ export const $: g_glossary.D.Glossary = {
     'root': {
         'namespaces': d({}),
         'data types': d({
-            "Array": parametrizedType({ "Type": null }, array(ref(typeReference("KeyValuePair", { "Type": typeParameter("Type") })))),
-            "KeyValuePair": parametrizedType({ "Type": null }, group({
-                "key": member(string()),
-                "value": member(ref(typeParameter("Type"))),
-            })),
 
-            "DependencyDictionary": parametrizedType({ "Type": null }, dictionary(group({
-                "value": member(ref(typeParameter("Type"))),
-                "dependencies": member(dictionary(null_())),
-            }))),
         }),
     },
     'interface types': d({}),
     'algorithm types': d({
-        "SortTopologically": sfunction(
-            typeReference("Array", { "Type": typeParameter("Type") }),
-            data(typeReference("DependencyDictionary", { "Type": typeParameter("Type") })),
-            { "Type": null }
-        ),
     }),
 }

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

@@ -10,8 +10,20 @@ import { glossary, group, member, number, type } from "pareto-pure/auto.dist/pub
 export const $: g_project.D.API = api(
     glos,
     {
-        "join": algorithm("Join", null, {}),
+        "join 2 strings": algorithm("Join 2 Strings", null, {}),
+        "join array of strings": algorithm("Join Array Of Strings", null, {}),
         "repeat": algorithm("Repeat", null, {}),
-        "foo": algorithm("Foo", null, {}),
+
+        /**
+         * 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", {}),
+
+        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
+        
+        //this one implicitely sorts the keys
+        //"getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
+
+        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
     }
 )

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

@@ -4,7 +4,8 @@ import {
     aInterface,
     aInterfaceMethod,
     aInterfaceReference,
-    array, boolean, data, group, member, number, optional, sfunction, streamconsumer, string, type, typeReference
+    array, boolean,
+    data, dictionary, group, member, number, optional, parametrizedType, ref, sfunction, streamconsumer, string, 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"
@@ -19,21 +20,69 @@ export const $: g_glossary.D.Glossary = {
         'namespaces': d({}),
         'data types': d({
             "String": type(string()),
-            "JoinData": type(group({
+            "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()),
             })),
+
+            "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")))),
+
         }),
     },
     '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"))),
+        "Join Array Of Strings": sfunction(
+            typeReference("String"),
+            data(typeReference("Join Array Of Strings", { "T": typeParameter("T") })),
+            { "T": null }
+        ),
+        "Join 2 Strings": sfunction(
+            typeReference("String"),
+            data(typeReference("Join 2 Strings"))
+        ),
+        "Repeat": sfunction(
+            typeReference("String"),
+            data(typeReference("RepeatData"))
+        ),
+        "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-pure/auto.dependencies/pareto-standard-library/modules/tostring/api.data.ts

@@ -9,13 +9,6 @@ import { glossary, member, type, group, string, optional, number } from "pareto-
 export const $: g_project.D.API = api(
     glos,
     {
-        "getArrayAsString": algorithm("GetArrayAsString", "Configuration", {}),
-        "getLengthAsString": algorithm("GetLengthAsString", null, {}),
-        
-        //this one implicitely sorts the keys
-        //"getKeysAsString": algorithm("GetKeysAsString", "Configuration", {}),
-
-        "getNumberOfKeysAsString": algorithm("GetNumberOfKeysAsString", null, {}),
 
     }
 )

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

@@ -19,23 +19,10 @@ export const $: g_glossary.D.Glossary = {
         '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-pure/glossaries/auto.cosmos_type_system.data.ts

@@ -172,6 +172,47 @@ export const $: g_cosmos.D.Glossary = {
                     })],
                 })]
             },
+            "Data Glossary": {
+                'parameters': d({}),
+                'type': <g_cosmos.D.Data__Type>['group', d({
+                    "glossary parameters": {
+                        'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                            'context': ['local', null],
+                            'typeXX': "Parameters",
+                            'tailXX': a([]),
+                            'type arguments': d({}),
+                        }]],
+                    },
+                    "imports": {
+                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
+                            "glossary": {
+                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                                    'context': ['local', null],
+                                    'typeXX': "Glossary",
+                                    'tailXX': a([]),
+                                    'type arguments': d({}),
+                                }]],
+                            },
+                            "type arguments": {
+                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                                    'context': ['local', null],
+                                    'typeXX': "Arguments",
+                                    'tailXX': a([]),
+                                    'type arguments': d({}),
+                                }]],
+                            },
+                        })]],
+                    },
+                    "root": {
+                        'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                            'context': ['local', null],
+                            'typeXX': "Namespace",
+                            'tailXX': a([]),
+                            'type arguments': d({}),
+                        }]],
+                    },
+                })]
+            },
             "Data Or Synchronous Interface": {
                 'parameters': d({}),
                 'type': <g_cosmos.D.Data__Type>['taggedUnion', d({
@@ -395,34 +436,14 @@ export const $: g_cosmos.D.Glossary = {
                             },
                         })]],
                     },
-                    "glossary parameters": {
+                    "data glossary": {
                         'type': <g_cosmos.D.Data__Type>['reference', ['type', {
                             'context': ['local', null],
-                            'typeXX': "Parameters",
+                            'typeXX': "Data Glossary",
                             'tailXX': a([]),
                             'type arguments': d({}),
                         }]],
                     },
-                    "imports": {
-                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
-                            "glossary": {
-                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
-                                    'context': ['local', null],
-                                    'typeXX': "Glossary",
-                                    'tailXX': a([]),
-                                    'type arguments': d({}),
-                                }]],
-                            },
-                            "type arguments": {
-                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
-                                    'context': ['local', null],
-                                    'typeXX': "Arguments",
-                                    'tailXX': a([]),
-                                    'type arguments': d({}),
-                                }]],
-                            },
-                        })]],
-                    },
                     "interface types": {
                         'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
                             "parameters": {
@@ -459,14 +480,6 @@ export const $: g_cosmos.D.Glossary = {
                             },
                         })]],
                     },
-                    "root": {
-                        'type': <g_cosmos.D.Data__Type>['reference', ['type', {
-                            'context': ['local', null],
-                            'typeXX': "Namespace",
-                            'tailXX': a([]),
-                            'type arguments': d({}),
-                        }]],
-                    },
                 })]
             },
             "Glossary Reference": {
@@ -540,12 +553,19 @@ export const $: g_cosmos.D.Glossary = {
                 'parameters': d({}),
                 'type': <g_cosmos.D.Data__Type>['group', d({
                     "glossaries": {
-                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['reference', ['type', {
-                            'context': ['local', null],
-                            'typeXX': "Glossary",
-                            'tailXX': a([]),
-                            'type arguments': d({}),
-                        }]]],
+                        'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['group', d({
+                            "description": {
+                                'type': <g_cosmos.D.Data__Type>['string', null],
+                            },
+                            "glossary": {
+                                'type': <g_cosmos.D.Data__Type>['reference', ['type', {
+                                    'context': ['local', null],
+                                    'typeXX': "Glossary",
+                                    'tailXX': a([]),
+                                    'type arguments': d({}),
+                                }]],
+                            },
+                        })]],
                     },
                     "modules": {
                         'type': <g_cosmos.D.Data__Type>['dictionary', <g_cosmos.D.Data__Type>['reference', ['type', {
@@ -942,6 +962,47 @@ export const $: g_cosmos.D.Glossary = {
                     },
                 }),
             },
+            "Data Glossary": {
+                'data types': d({}),
+                'namespaces': d({
+                    "G": {
+                        'data types': d({}),
+                        'namespaces': d({
+                            "glossary parameters": {
+                                'data types': d({}),
+                                'namespaces': d({}),
+                            },
+                            "imports": {
+                                'data types': d({}),
+                                'namespaces': d({
+                                    "DX": {
+                                        'data types': d({}),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "glossary": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                    "type arguments": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                }),
+                                            },
+                                        }),
+                                    },
+                                }),
+                            },
+                            "root": {
+                                'data types': d({}),
+                                'namespaces': d({}),
+                            },
+                        }),
+                    },
+                }),
+            },
             "Data Or Synchronous Interface": {
                 'data types': d({}),
                 'namespaces': d({
@@ -1271,33 +1332,10 @@ export const $: g_cosmos.D.Glossary = {
                                     },
                                 }),
                             },
-                            "glossary parameters": {
+                            "data glossary": {
                                 'data types': d({}),
                                 'namespaces': d({}),
                             },
-                            "imports": {
-                                'data types': d({}),
-                                'namespaces': d({
-                                    "DX": {
-                                        'data types': d({}),
-                                        'namespaces': d({
-                                            "G": {
-                                                'data types': d({}),
-                                                'namespaces': d({
-                                                    "glossary": {
-                                                        'data types': d({}),
-                                                        'namespaces': d({}),
-                                                    },
-                                                    "type arguments": {
-                                                        'data types': d({}),
-                                                        'namespaces': d({}),
-                                                    },
-                                                }),
-                                            },
-                                        }),
-                                    },
-                                }),
-                            },
                             "interface types": {
                                 'data types': d({}),
                                 'namespaces': d({
@@ -1355,10 +1393,6 @@ export const $: g_cosmos.D.Glossary = {
                                     },
                                 }),
                             },
-                            "root": {
-                                'data types': d({}),
-                                'namespaces': d({}),
-                            },
                         }),
                     },
                 }),
@@ -1484,7 +1518,21 @@ export const $: g_cosmos.D.Glossary = {
                                 'namespaces': d({
                                     "DX": {
                                         'data types': d({}),
-                                        'namespaces': d({}),
+                                        'namespaces': d({
+                                            "G": {
+                                                'data types': d({}),
+                                                'namespaces': d({
+                                                    "description": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                    "glossary": {
+                                                        'data types': d({}),
+                                                        'namespaces': d({}),
+                                                    },
+                                                }),
+                                            },
+                                        }),
                                     },
                                 }),
                             },