pareto 0.52.0 → 0.54.0

package/auto.dist/public/glossaries/cosmos__type__system.d.ts

@@ -0,0 +1,1760 @@
+import * as pt from 'pareto-core-types';
+export declare namespace G { }
+export declare namespace N {
+    namespace Algorithm_$_$Type_$_$Reference {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace algorithm_$_$type {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace API {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace algorithms {
+                        namespace N {
+                            namespace DX {
+                                namespace N {
+                                    namespace G {
+                                        namespace N {
+                                            namespace configuration_$_$data {
+                                                namespace N {
+                                                    namespace O {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace definition {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace dependencies {
+                                                namespace N {
+                                                    namespace DX {
+                                                        namespace N {
+                                                            namespace G {
+                                                                namespace N {
+                                                                    namespace algorithm_$_$type {
+                                                                        namespace N { }
+                                                                        namespace D { }
+                                                                    }
+                                                                    namespace _$lmodule {
+                                                                        namespace N { }
+                                                                        namespace D { }
+                                                                    }
+                                                                    namespace _$ltype {
+                                                                        namespace N {
+                                                                            namespace TU {
+                                                                                namespace N {
+                                                                                    namespace library_$_$dependency {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                    namespace _$lprivate {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                    namespace _$lpublic {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                    namespace sibling {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                    namespace type_$_$arguments {
+                                                                        namespace N {
+                                                                            namespace DX {
+                                                                                namespace N {
+                                                                                    namespace TU {
+                                                                                        namespace N {
+                                                                                            namespace api_$_$parameter {
+                                                                                                namespace N { }
+                                                                                                namespace D { }
+                                                                                            }
+                                                                                            namespace data_$_$type {
+                                                                                                namespace N { }
+                                                                                                namespace D { }
+                                                                                            }
+                                                                                        }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace provided_$_$interface {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Arguments {
+        namespace N {
+            namespace DX {
+                namespace N { }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Asynchronous_$_$Interface_$_$Reference {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace context {
+                        namespace N {
+                            namespace TU {
+                                namespace N {
+                                    namespace _$limport {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N {
+                                                    namespace glossary {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace local {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace interfaceXX {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace type_$_$arguments {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Asynchronous_$_$Interface_$_$Type {
+        namespace N {
+            namespace TU {
+                namespace N {
+                    namespace choice {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace options {
+                                        namespace N {
+                                            namespace DX {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace method {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace data {
+                                        namespace N {
+                                            namespace O {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace _$linterface {
+                                        namespace N {
+                                            namespace O {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace reference {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace streamconsumer {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace data {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                    namespace end {
+                                        namespace N {
+                                            namespace O {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Data_$_$Or_$_$Synchronous_$_$Interface {
+        namespace N {
+            namespace TU {
+                namespace N {
+                    namespace data {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace _$linterface {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Data_$_$Type {
+        namespace N {
+            namespace TU {
+                namespace N {
+                    namespace array {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace _$lboolean {
+                        namespace N {
+                            namespace G {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace computed {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace dictionary {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace group {
+                        namespace N {
+                            namespace DX {
+                                namespace N {
+                                    namespace G {
+                                        namespace N {
+                                            namespace _$ltype {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace _$lnull {
+                        namespace N {
+                            namespace G {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace _$lnumber {
+                        namespace N {
+                            namespace G {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace optional {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace reference {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace _$lstring {
+                        namespace N {
+                            namespace G {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace taggedUnion {
+                        namespace N {
+                            namespace DX {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace DataSpecifier {
+        namespace N {
+            namespace TU {
+                namespace N {
+                    namespace glossary_$_$parameterXX {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace _$ltype {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace context {
+                                        namespace N {
+                                            namespace TU {
+                                                namespace N {
+                                                    namespace _$limport {
+                                                        namespace N {
+                                                            namespace G {
+                                                                namespace N {
+                                                                    namespace glossary {
+                                                                        namespace N { }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                    namespace local {
+                                                        namespace N {
+                                                            namespace G {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace tailXX {
+                                        namespace N {
+                                            namespace A {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace type_$_$arguments {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                    namespace typeXX {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace type_$_$parameterXX {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Dummy {
+        namespace N {
+            namespace G {
+                namespace N { }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Glossary {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace algorithm_$_$types {
+                        namespace N {
+                            namespace DX {
+                                namespace N {
+                                    namespace G {
+                                        namespace N {
+                                            namespace parameters {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace _$ltype {
+                                                namespace N {
+                                                    namespace TU {
+                                                        namespace N {
+                                                            namespace asynchronous_$_$function {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace _$lin {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace out {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                            namespace interface_$_$initializer {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace downstreams {
+                                                                                namespace N {
+                                                                                    namespace DX {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace _$linterface {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                            namespace procedure {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace _$lin {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace out {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                            namespace resource_$_$initializer {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace consumer {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace request {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                            namespace synchronous_$_$function {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace _$lin {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace out {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace glossary_$_$parameters {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace imports {
+                        namespace N {
+                            namespace DX {
+                                namespace N {
+                                    namespace G {
+                                        namespace N {
+                                            namespace glossary {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace type_$_$arguments {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace interface_$_$types {
+                        namespace N {
+                            namespace DX {
+                                namespace N {
+                                    namespace G {
+                                        namespace N {
+                                            namespace parameters {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace _$ltype {
+                                                namespace N {
+                                                    namespace TU {
+                                                        namespace N {
+                                                            namespace asynchronous {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace _$linterface {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                            namespace synchronous {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace _$linterface {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace root {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Glossary_$_$Reference {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace glossary {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Library {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace author {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace description {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace license {
+                        namespace N { }
+                        namespace D { }
+                    }
+                    namespace module_$_$sets {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace _$lprivate {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                    namespace _$lpublic {
+                                        namespace N { }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace _$ltype {
+                        namespace N {
+                            namespace TU {
+                                namespace N {
+                                    namespace impure {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace pure {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N {
+                                                    namespace dependencies {
+                                                        namespace N {
+                                                            namespace DX {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace library {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace version {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Module_$_$Set {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace glossaries {
+                        namespace N {
+                            namespace DX {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace modules {
+                        namespace N {
+                            namespace DX {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Namespace {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace data_$_$types {
+                        namespace N {
+                            namespace DX {
+                                namespace N {
+                                    namespace G {
+                                        namespace N {
+                                            namespace parameters {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace _$ltype {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace namespaces {
+                        namespace N {
+                            namespace DX {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Parameters {
+        namespace N {
+            namespace DX {
+                namespace N {
+                    namespace G {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Synchronous_$_$Interface_$_$Reference {
+        namespace N {
+            namespace G {
+                namespace N {
+                    namespace context {
+                        namespace N {
+                            namespace TU {
+                                namespace N {
+                                    namespace _$limport {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N {
+                                                    namespace glossary {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                    namespace interfaceXX {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace local {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N {
+                                                    namespace interfaceXX {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace type_$_$arguments {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+    namespace Synchronous_$_$Interface_$_$Type {
+        namespace N {
+            namespace TU {
+                namespace N {
+                    namespace group {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace members {
+                                        namespace N {
+                                            namespace DX {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace method {
+                        namespace N {
+                            namespace G {
+                                namespace N {
+                                    namespace data {
+                                        namespace N {
+                                            namespace O {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                    namespace _$linterface {
+                                        namespace N {
+                                            namespace O {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                    namespace reference {
+                        namespace N { }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D { }
+    }
+}
+export declare namespace D {
+    namespace Algorithm__Type__Reference {
+        type algorithm__type = string;
+    }
+    type Algorithm__Type__Reference = {
+        readonly 'algorithm type': string;
+    };
+    namespace API {
+        namespace algorithms {
+            namespace DX {
+                namespace configuration__data {
+                    type O = string;
+                }
+                type configuration__data = pt.OptionalValue<string>;
+                type definition = D.Algorithm__Type__Reference;
+                namespace dependencies {
+                    namespace DX {
+                        type algorithm__type = D.Algorithm__Type__Reference;
+                        type _lmodule = string;
+                        namespace _ltype {
+                            type library__dependency = string;
+                            type _lprivate = null;
+                            type _lpublic = null;
+                            type sibling = null;
+                        }
+                        type _ltype = ['library dependency', string] | ['private', null] | ['public', null] | ['sibling', null];
+                        namespace type__arguments {
+                            namespace DX {
+                                type api__parameter = string;
+                                type data__type = string;
+                            }
+                            type DX = ['api parameter', string] | ['data type', string];
+                        }
+                        type type__arguments = pt.Dictionary<['api parameter', string] | ['data type', string]>;
+                    }
+                    type DX = {
+                        readonly 'algorithm type': D.Algorithm__Type__Reference;
+                        readonly 'module': string;
+                        readonly 'type': ['library dependency', string] | ['private', null] | ['public', null] | ['sibling', null];
+                        readonly 'type arguments': pt.Dictionary<['api parameter', string] | ['data type', string]>;
+                    };
+                }
+                type dependencies = pt.Dictionary<{
+                    readonly 'algorithm type': D.Algorithm__Type__Reference;
+                    readonly 'module': string;
+                    readonly 'type': ['library dependency', string] | ['private', null] | ['public', null] | ['sibling', null];
+                    readonly 'type arguments': pt.Dictionary<['api parameter', string] | ['data type', string]>;
+                }>;
+            }
+            type DX = {
+                readonly 'configuration data': pt.OptionalValue<string>;
+                readonly 'definition': D.Algorithm__Type__Reference;
+                readonly 'dependencies': pt.Dictionary<{
+                    readonly 'algorithm type': D.Algorithm__Type__Reference;
+                    readonly 'module': string;
+                    readonly 'type': ['library dependency', string] | ['private', null] | ['public', null] | ['sibling', null];
+                    readonly 'type arguments': pt.Dictionary<['api parameter', string] | ['data type', string]>;
+                }>;
+            };
+        }
+        type algorithms = pt.Dictionary<{
+            readonly 'configuration data': pt.OptionalValue<string>;
+            readonly 'definition': D.Algorithm__Type__Reference;
+            readonly 'dependencies': pt.Dictionary<{
+                readonly 'algorithm type': D.Algorithm__Type__Reference;
+                readonly 'module': string;
+                readonly 'type': ['library dependency', string] | ['private', null] | ['public', null] | ['sibling', null];
+                readonly 'type arguments': pt.Dictionary<['api parameter', string] | ['data type', string]>;
+            }>;
+        }>;
+        type provided__interface = D.Glossary;
+    }
+    type API = {
+        readonly 'algorithms': pt.Dictionary<{
+            readonly 'configuration data': pt.OptionalValue<string>;
+            readonly 'definition': D.Algorithm__Type__Reference;
+            readonly 'dependencies': pt.Dictionary<{
+                readonly 'algorithm type': D.Algorithm__Type__Reference;
+                readonly 'module': string;
+                readonly 'type': ['library dependency', string] | ['private', null] | ['public', null] | ['sibling', null];
+                readonly 'type arguments': pt.Dictionary<['api parameter', string] | ['data type', string]>;
+            }>;
+        }>;
+        readonly 'provided interface': D.Glossary;
+    };
+    namespace Arguments {
+        type DX = D.DataSpecifier;
+    }
+    type Arguments = pt.Dictionary<D.DataSpecifier>;
+    namespace Asynchronous__Interface__Reference {
+        namespace context {
+            namespace _limport {
+                type glossary = D.Glossary__Reference;
+            }
+            type _limport = {
+                readonly 'glossary': D.Glossary__Reference;
+            };
+            namespace local { }
+            type local = null;
+        }
+        type context = [
+            'import',
+            {
+                readonly 'glossary': D.Glossary__Reference;
+            }
+        ] | ['local', null];
+        type interfaceXX = string;
+        type type__arguments = D.Arguments;
+    }
+    type Asynchronous__Interface__Reference = {
+        readonly 'context': [
+            'import',
+            {
+                readonly 'glossary': D.Glossary__Reference;
+            }
+        ] | ['local', null];
+        readonly 'interfaceXX': string;
+        readonly 'type arguments': D.Arguments;
+    };
+    namespace Asynchronous__Interface__Type {
+        namespace choice {
+            namespace options {
+                type DX = D.Asynchronous__Interface__Type;
+            }
+            type options = pt.Dictionary<D.Asynchronous__Interface__Type>;
+        }
+        type choice = {
+            readonly 'options': pt.Dictionary<D.Asynchronous__Interface__Type>;
+        };
+        namespace method {
+            namespace data {
+                type O = D.DataSpecifier;
+            }
+            type data = pt.OptionalValue<D.DataSpecifier>;
+            namespace _linterface {
+                type O = D.Asynchronous__Interface__Type;
+            }
+            type _linterface = pt.OptionalValue<D.Asynchronous__Interface__Type>;
+        }
+        type method = {
+            readonly 'data': pt.OptionalValue<D.DataSpecifier>;
+            readonly 'interface': pt.OptionalValue<D.Asynchronous__Interface__Type>;
+        };
+        type reference = D.Asynchronous__Interface__Reference;
+        namespace streamconsumer {
+            type data = D.Asynchronous__Interface__Type;
+            namespace end {
+                type O = D.Asynchronous__Interface__Type;
+            }
+            type end = pt.OptionalValue<D.Asynchronous__Interface__Type>;
+        }
+        type streamconsumer = {
+            readonly 'data': D.Asynchronous__Interface__Type;
+            readonly 'end': pt.OptionalValue<D.Asynchronous__Interface__Type>;
+        };
+    }
+    type Asynchronous__Interface__Type = [
+        'choice',
+        {
+            readonly 'options': pt.Dictionary<D.Asynchronous__Interface__Type>;
+        }
+    ] | [
+        'method',
+        {
+            readonly 'data': pt.OptionalValue<D.DataSpecifier>;
+            readonly 'interface': pt.OptionalValue<D.Asynchronous__Interface__Type>;
+        }
+    ] | ['reference', D.Asynchronous__Interface__Reference] | [
+        'streamconsumer',
+        {
+            readonly 'data': D.Asynchronous__Interface__Type;
+            readonly 'end': pt.OptionalValue<D.Asynchronous__Interface__Type>;
+        }
+    ];
+    namespace Data__Or__Synchronous__Interface {
+        type data = D.DataSpecifier;
+        type _linterface = D.Synchronous__Interface__Reference;
+    }
+    type Data__Or__Synchronous__Interface = ['data', D.DataSpecifier] | ['interface', D.Synchronous__Interface__Reference];
+    namespace Data__Type {
+        type array = D.Data__Type;
+        namespace _lboolean { }
+        type _lboolean = null;
+        type computed = D.Data__Type;
+        type dictionary = D.Data__Type;
+        namespace group {
+            namespace DX {
+                type _ltype = D.Data__Type;
+            }
+            type DX = {
+                readonly 'type': D.Data__Type;
+            };
+        }
+        type group = pt.Dictionary<{
+            readonly 'type': D.Data__Type;
+        }>;
+        namespace _lnull { }
+        type _lnull = null;
+        namespace _lnumber { }
+        type _lnumber = null;
+        type optional = D.Data__Type;
+        type reference = D.DataSpecifier;
+        namespace _lstring { }
+        type _lstring = null;
+        namespace taggedUnion {
+            type DX = D.Data__Type;
+        }
+        type taggedUnion = pt.Dictionary<D.Data__Type>;
+    }
+    type Data__Type = ['array', D.Data__Type] | ['boolean', null] | ['computed', D.Data__Type] | ['dictionary', D.Data__Type] | [
+        'group',
+        pt.Dictionary<{
+            readonly 'type': D.Data__Type;
+        }>
+    ] | ['null', null] | ['number', null] | ['optional', D.Data__Type] | ['reference', D.DataSpecifier] | ['string', null] | ['taggedUnion', pt.Dictionary<D.Data__Type>];
+    namespace DataSpecifier {
+        type glossary__parameterXX = string;
+        namespace _ltype {
+            namespace context {
+                namespace _limport {
+                    type glossary = D.Glossary__Reference;
+                }
+                type _limport = {
+                    readonly 'glossary': D.Glossary__Reference;
+                };
+                namespace local { }
+                type local = null;
+            }
+            type context = [
+                'import',
+                {
+                    readonly 'glossary': D.Glossary__Reference;
+                }
+            ] | ['local', null];
+            namespace tailXX {
+                type A = string;
+            }
+            type tailXX = pt.Array<string>;
+            type type__arguments = D.Arguments;
+            type typeXX = string;
+        }
+        type _ltype = {
+            readonly 'context': [
+                'import',
+                {
+                    readonly 'glossary': D.Glossary__Reference;
+                }
+            ] | ['local', null];
+            readonly 'tailXX': pt.Array<string>;
+            readonly 'type arguments': D.Arguments;
+            readonly 'typeXX': string;
+        };
+        type type__parameterXX = string;
+    }
+    type DataSpecifier = ['glossary parameterXX', string] | [
+        'type',
+        {
+            readonly 'context': [
+                'import',
+                {
+                    readonly 'glossary': D.Glossary__Reference;
+                }
+            ] | ['local', null];
+            readonly 'tailXX': pt.Array<string>;
+            readonly 'type arguments': D.Arguments;
+            readonly 'typeXX': string;
+        }
+    ] | ['type parameterXX', string];
+    namespace Dummy { }
+    type Dummy = null;
+    namespace Glossary {
+        namespace algorithm__types {
+            namespace DX {
+                type parameters = D.Parameters;
+                namespace _ltype {
+                    namespace asynchronous__function {
+                        type _lin = D.DataSpecifier;
+                        type out = D.DataSpecifier;
+                    }
+                    type asynchronous__function = {
+                        readonly 'in': D.DataSpecifier;
+                        readonly 'out': D.DataSpecifier;
+                    };
+                    namespace interface__initializer {
+                        namespace downstreams {
+                            type DX = D.Asynchronous__Interface__Reference;
+                        }
+                        type downstreams = pt.Dictionary<D.Asynchronous__Interface__Reference>;
+                        type _linterface = D.Asynchronous__Interface__Reference;
+                    }
+                    type interface__initializer = {
+                        readonly 'downstreams': pt.Dictionary<D.Asynchronous__Interface__Reference>;
+                        readonly 'interface': D.Asynchronous__Interface__Reference;
+                    };
+                    namespace procedure {
+                        type _lin = D.Data__Or__Synchronous__Interface;
+                        type out = D.Synchronous__Interface__Reference;
+                    }
+                    type procedure = {
+                        readonly 'in': D.Data__Or__Synchronous__Interface;
+                        readonly 'out': D.Synchronous__Interface__Reference;
+                    };
+                    namespace resource__initializer {
+                        type consumer = D.Asynchronous__Interface__Reference;
+                        type request = D.DataSpecifier;
+                    }
+                    type resource__initializer = {
+                        readonly 'consumer': D.Asynchronous__Interface__Reference;
+                        readonly 'request': D.DataSpecifier;
+                    };
+                    namespace synchronous__function {
+                        type _lin = D.Data__Or__Synchronous__Interface;
+                        type out = D.DataSpecifier;
+                    }
+                    type synchronous__function = {
+                        readonly 'in': D.Data__Or__Synchronous__Interface;
+                        readonly 'out': D.DataSpecifier;
+                    };
+                }
+                type _ltype = [
+                    'asynchronous function',
+                    {
+                        readonly 'in': D.DataSpecifier;
+                        readonly 'out': D.DataSpecifier;
+                    }
+                ] | [
+                    'interface initializer',
+                    {
+                        readonly 'downstreams': pt.Dictionary<D.Asynchronous__Interface__Reference>;
+                        readonly 'interface': D.Asynchronous__Interface__Reference;
+                    }
+                ] | [
+                    'procedure',
+                    {
+                        readonly 'in': D.Data__Or__Synchronous__Interface;
+                        readonly 'out': D.Synchronous__Interface__Reference;
+                    }
+                ] | [
+                    'resource initializer',
+                    {
+                        readonly 'consumer': D.Asynchronous__Interface__Reference;
+                        readonly 'request': D.DataSpecifier;
+                    }
+                ] | [
+                    'synchronous function',
+                    {
+                        readonly 'in': D.Data__Or__Synchronous__Interface;
+                        readonly 'out': D.DataSpecifier;
+                    }
+                ];
+            }
+            type DX = {
+                readonly 'parameters': D.Parameters;
+                readonly 'type': [
+                    'asynchronous function',
+                    {
+                        readonly 'in': D.DataSpecifier;
+                        readonly 'out': D.DataSpecifier;
+                    }
+                ] | [
+                    'interface initializer',
+                    {
+                        readonly 'downstreams': pt.Dictionary<D.Asynchronous__Interface__Reference>;
+                        readonly 'interface': D.Asynchronous__Interface__Reference;
+                    }
+                ] | [
+                    'procedure',
+                    {
+                        readonly 'in': D.Data__Or__Synchronous__Interface;
+                        readonly 'out': D.Synchronous__Interface__Reference;
+                    }
+                ] | [
+                    'resource initializer',
+                    {
+                        readonly 'consumer': D.Asynchronous__Interface__Reference;
+                        readonly 'request': D.DataSpecifier;
+                    }
+                ] | [
+                    'synchronous function',
+                    {
+                        readonly 'in': D.Data__Or__Synchronous__Interface;
+                        readonly 'out': D.DataSpecifier;
+                    }
+                ];
+            };
+        }
+        type algorithm__types = pt.Dictionary<{
+            readonly 'parameters': D.Parameters;
+            readonly 'type': [
+                'asynchronous function',
+                {
+                    readonly 'in': D.DataSpecifier;
+                    readonly 'out': D.DataSpecifier;
+                }
+            ] | [
+                'interface initializer',
+                {
+                    readonly 'downstreams': pt.Dictionary<D.Asynchronous__Interface__Reference>;
+                    readonly 'interface': D.Asynchronous__Interface__Reference;
+                }
+            ] | [
+                'procedure',
+                {
+                    readonly 'in': D.Data__Or__Synchronous__Interface;
+                    readonly 'out': D.Synchronous__Interface__Reference;
+                }
+            ] | [
+                'resource initializer',
+                {
+                    readonly 'consumer': D.Asynchronous__Interface__Reference;
+                    readonly 'request': D.DataSpecifier;
+                }
+            ] | [
+                'synchronous function',
+                {
+                    readonly 'in': D.Data__Or__Synchronous__Interface;
+                    readonly 'out': D.DataSpecifier;
+                }
+            ];
+        }>;
+        type glossary__parameters = D.Parameters;
+        namespace imports {
+            namespace DX {
+                type glossary = D.Glossary;
+                type type__arguments = D.Arguments;
+            }
+            type DX = {
+                readonly 'glossary': D.Glossary;
+                readonly 'type arguments': D.Arguments;
+            };
+        }
+        type imports = pt.Dictionary<{
+            readonly 'glossary': D.Glossary;
+            readonly 'type arguments': D.Arguments;
+        }>;
+        namespace interface__types {
+            namespace DX {
+                type parameters = D.Parameters;
+                namespace _ltype {
+                    namespace asynchronous {
+                        type _linterface = D.Asynchronous__Interface__Type;
+                    }
+                    type asynchronous = {
+                        readonly 'interface': D.Asynchronous__Interface__Type;
+                    };
+                    namespace synchronous {
+                        type _linterface = D.Synchronous__Interface__Type;
+                    }
+                    type synchronous = {
+                        readonly 'interface': D.Synchronous__Interface__Type;
+                    };
+                }
+                type _ltype = [
+                    'asynchronous',
+                    {
+                        readonly 'interface': D.Asynchronous__Interface__Type;
+                    }
+                ] | [
+                    'synchronous',
+                    {
+                        readonly 'interface': D.Synchronous__Interface__Type;
+                    }
+                ];
+            }
+            type DX = {
+                readonly 'parameters': D.Parameters;
+                readonly 'type': [
+                    'asynchronous',
+                    {
+                        readonly 'interface': D.Asynchronous__Interface__Type;
+                    }
+                ] | [
+                    'synchronous',
+                    {
+                        readonly 'interface': D.Synchronous__Interface__Type;
+                    }
+                ];
+            };
+        }
+        type interface__types = pt.Dictionary<{
+            readonly 'parameters': D.Parameters;
+            readonly 'type': [
+                'asynchronous',
+                {
+                    readonly 'interface': D.Asynchronous__Interface__Type;
+                }
+            ] | [
+                'synchronous',
+                {
+                    readonly 'interface': D.Synchronous__Interface__Type;
+                }
+            ];
+        }>;
+        type root = D.Namespace;
+    }
+    type Glossary = {
+        readonly 'algorithm types': pt.Dictionary<{
+            readonly 'parameters': D.Parameters;
+            readonly 'type': [
+                'asynchronous function',
+                {
+                    readonly 'in': D.DataSpecifier;
+                    readonly 'out': D.DataSpecifier;
+                }
+            ] | [
+                'interface initializer',
+                {
+                    readonly 'downstreams': pt.Dictionary<D.Asynchronous__Interface__Reference>;
+                    readonly 'interface': D.Asynchronous__Interface__Reference;
+                }
+            ] | [
+                'procedure',
+                {
+                    readonly 'in': D.Data__Or__Synchronous__Interface;
+                    readonly 'out': D.Synchronous__Interface__Reference;
+                }
+            ] | [
+                'resource initializer',
+                {
+                    readonly 'consumer': D.Asynchronous__Interface__Reference;
+                    readonly 'request': D.DataSpecifier;
+                }
+            ] | [
+                'synchronous function',
+                {
+                    readonly 'in': D.Data__Or__Synchronous__Interface;
+                    readonly 'out': D.DataSpecifier;
+                }
+            ];
+        }>;
+        readonly 'glossary parameters': D.Parameters;
+        readonly 'imports': pt.Dictionary<{
+            readonly 'glossary': D.Glossary;
+            readonly 'type arguments': D.Arguments;
+        }>;
+        readonly 'interface types': pt.Dictionary<{
+            readonly 'parameters': D.Parameters;
+            readonly 'type': [
+                'asynchronous',
+                {
+                    readonly 'interface': D.Asynchronous__Interface__Type;
+                }
+            ] | [
+                'synchronous',
+                {
+                    readonly 'interface': D.Synchronous__Interface__Type;
+                }
+            ];
+        }>;
+        readonly 'root': D.Namespace;
+    };
+    namespace Glossary__Reference {
+        type glossary = string;
+    }
+    type Glossary__Reference = {
+        readonly 'glossary': string;
+    };
+    namespace Library {
+        type author = string;
+        type description = string;
+        type license = string;
+        namespace module__sets {
+            type _lprivate = D.Module__Set;
+            type _lpublic = D.Module__Set;
+        }
+        type module__sets = {
+            readonly 'private': D.Module__Set;
+            readonly 'public': D.Module__Set;
+        };
+        namespace _ltype {
+            namespace impure { }
+            type impure = null;
+            namespace pure {
+                namespace dependencies {
+                    namespace DX {
+                        type library = D.Library;
+                        type version = string;
+                    }
+                    type DX = {
+                        readonly 'library': D.Library;
+                        readonly 'version': string;
+                    };
+                }
+                type dependencies = pt.Dictionary<{
+                    readonly 'library': D.Library;
+                    readonly 'version': string;
+                }>;
+            }
+            type pure = {
+                readonly 'dependencies': pt.Dictionary<{
+                    readonly 'library': D.Library;
+                    readonly 'version': string;
+                }>;
+            };
+        }
+        type _ltype = ['impure', null] | [
+            'pure',
+            {
+                readonly 'dependencies': pt.Dictionary<{
+                    readonly 'library': D.Library;
+                    readonly 'version': string;
+                }>;
+            }
+        ];
+    }
+    type Library = {
+        readonly 'author': string;
+        readonly 'description': string;
+        readonly 'license': string;
+        readonly 'module sets': {
+            readonly 'private': D.Module__Set;
+            readonly 'public': D.Module__Set;
+        };
+        readonly 'type': ['impure', null] | [
+            'pure',
+            {
+                readonly 'dependencies': pt.Dictionary<{
+                    readonly 'library': D.Library;
+                    readonly 'version': string;
+                }>;
+            }
+        ];
+    };
+    namespace Module__Set {
+        namespace glossaries {
+            type DX = D.Glossary;
+        }
+        type glossaries = pt.Dictionary<D.Glossary>;
+        namespace modules {
+            type DX = D.API;
+        }
+        type modules = pt.Dictionary<D.API>;
+    }
+    type Module__Set = {
+        readonly 'glossaries': pt.Dictionary<D.Glossary>;
+        readonly 'modules': pt.Dictionary<D.API>;
+    };
+    namespace Namespace {
+        namespace data__types {
+            namespace DX {
+                type parameters = D.Parameters;
+                type _ltype = D.Data__Type;
+            }
+            type DX = {
+                readonly 'parameters': D.Parameters;
+                readonly 'type': D.Data__Type;
+            };
+        }
+        type data__types = pt.Dictionary<{
+            readonly 'parameters': D.Parameters;
+            readonly 'type': D.Data__Type;
+        }>;
+        namespace namespaces {
+            type DX = D.Namespace;
+        }
+        type namespaces = pt.Dictionary<D.Namespace>;
+    }
+    type Namespace = {
+        readonly 'data types': pt.Dictionary<{
+            readonly 'parameters': D.Parameters;
+            readonly 'type': D.Data__Type;
+        }>;
+        readonly 'namespaces': pt.Dictionary<D.Namespace>;
+    };
+    namespace Parameters {
+        namespace DX { }
+        type DX = null;
+    }
+    type Parameters = pt.Dictionary<null>;
+    namespace Synchronous__Interface__Reference {
+        namespace context {
+            namespace _limport {
+                type glossary = D.Glossary__Reference;
+                type interfaceXX = string;
+            }
+            type _limport = {
+                readonly 'glossary': D.Glossary__Reference;
+                readonly 'interfaceXX': string;
+            };
+            namespace local {
+                type interfaceXX = string;
+            }
+            type local = {
+                readonly 'interfaceXX': string;
+            };
+        }
+        type context = [
+            'import',
+            {
+                readonly 'glossary': D.Glossary__Reference;
+                readonly 'interfaceXX': string;
+            }
+        ] | [
+            'local',
+            {
+                readonly 'interfaceXX': string;
+            }
+        ];
+        type type__arguments = D.Arguments;
+    }
+    type Synchronous__Interface__Reference = {
+        readonly 'context': [
+            'import',
+            {
+                readonly 'glossary': D.Glossary__Reference;
+                readonly 'interfaceXX': string;
+            }
+        ] | [
+            'local',
+            {
+                readonly 'interfaceXX': string;
+            }
+        ];
+        readonly 'type arguments': D.Arguments;
+    };
+    namespace Synchronous__Interface__Type {
+        namespace group {
+            namespace members {
+                type DX = D.Synchronous__Interface__Type;
+            }
+            type members = pt.Dictionary<D.Synchronous__Interface__Type>;
+        }
+        type group = {
+            readonly 'members': pt.Dictionary<D.Synchronous__Interface__Type>;
+        };
+        namespace method {
+            namespace data {
+                type O = D.DataSpecifier;
+            }
+            type data = pt.OptionalValue<D.DataSpecifier>;
+            namespace _linterface {
+                type O = D.Synchronous__Interface__Type;
+            }
+            type _linterface = pt.OptionalValue<D.Synchronous__Interface__Type>;
+        }
+        type method = {
+            readonly 'data': pt.OptionalValue<D.DataSpecifier>;
+            readonly 'interface': pt.OptionalValue<D.Synchronous__Interface__Type>;
+        };
+        type reference = D.Synchronous__Interface__Reference;
+    }
+    type Synchronous__Interface__Type = [
+        'group',
+        {
+            readonly 'members': pt.Dictionary<D.Synchronous__Interface__Type>;
+        }
+    ] | [
+        'method',
+        {
+            readonly 'data': pt.OptionalValue<D.DataSpecifier>;
+            readonly 'interface': pt.OptionalValue<D.Synchronous__Interface__Type>;
+        }
+    ] | ['reference', D.Synchronous__Interface__Reference];
+}
+export declare namespace I { }
+export declare namespace A { }