pareto 0.55.0 → 0.57.0

package/auto.dist/public/cosmos__2__pareto/auto.provided_interface_glossary.d.ts

@@ -1,3045 +0,0 @@
-import * as pt from 'pareto-core-types';
-export declare namespace G {
-    namespace cosmos {
-        namespace G { }
-        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 { }
-            }
-        }
-        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];
-        }
-        namespace I { }
-        namespace A { }
-    }
-    namespace pareto {
-        namespace G { }
-        namespace N {
-            namespace Compilation_$_$Unit {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace imports {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace path {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace root_$_$namespace {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Expression {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace array_$_$literal {
-                                namespace N {
-                                    namespace A {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace block {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace change_$_$context {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace new_$_$context_$_$selection {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace sub_$_$expression {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace dictionary_$_$literal {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace _$lfalse {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lfunction {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace block {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace temp_$_$signature_$_$help {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace has_$_$additional_$_$parameters {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace has_$_$no_$_$additional_$_$parameters {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace typed {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace group_$_$literal {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace implement_$_$me {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace not_$_$set {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace null_$_$literal {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace number_$_$literal {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace panic {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace selection {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace start {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace context {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace parameter {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                            namespace variable {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace _$limport {
-                                                                                namespace N {
-                                                                                    namespace O {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace namespace_$_$path {
-                                                                                namespace N {
-                                                                                    namespace A {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace variable {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace tail {
-                                                namespace N {
-                                                    namespace A {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace call {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$larguments {
-                                                                                        namespace N {
-                                                                                            namespace DX {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace context {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                    namespace type_$_$arguments {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace member_$_$selection {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace _$lset {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace state_$_$literal {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace data {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace state {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace string_$_$literal {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lswitch {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace cases {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$ldefault {
-                                                namespace N {
-                                                    namespace O {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace select {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace ternary_$_$condition {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace condition {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace false_$_$expression {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace true_$_$expression {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace _$ltrue {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Function_$_$Signature {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace context_$_$parameter {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace parameters {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace return_$_$type {
-                                namespace N {
-                                    namespace O {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace type_$_$parameters {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Namespace {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace namespaces {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace types {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace _$ltype {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace type_$_$parameters {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace variables {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Statement_$_$Block {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace statements {
-                                namespace N {
-                                    namespace A {
-                                        namespace N {
-                                            namespace TU {
-                                                namespace N {
-                                                    namespace assignment {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace expression {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace selection {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace change_$_$context {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace new_$_$context_$_$selection {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace sub_$_$statement_$_$block {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace debug {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace expression {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$lif {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace condition {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace _$lelse {
-                                                                        namespace N {
-                                                                            namespace O {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace if_$_$block {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$lreturn {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace expression {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                    namespace sub_$_$block {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$lswitch {
-                                                        namespace N {
-                                                            namespace G {
-                                                                namespace N {
-                                                                    namespace cases {
-                                                                        namespace N {
-                                                                            namespace DX {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace _$ldefault {
-                                                                        namespace N {
-                                                                            namespace O {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace select {
-                                                                        namespace N { }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace variables {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace array {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lboolean {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace dictionary {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lfunction {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            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 _$lnull {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lnumber {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace optional {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace parameter_$_$selection {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lstring {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace tagged_$_$union {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace type_$_$selection {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace _$limport {
-                                                namespace N {
-                                                    namespace O {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace namespace_$_$path {
-                                                namespace N {
-                                                    namespace A {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$ltype {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace type_$_$arguments {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$_$Arguments {
-                namespace N {
-                    namespace DX {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Type_$_$Parameters {
-                namespace N {
-                    namespace DX {
-                        namespace N { }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Variables {
-                namespace N {
-                    namespace DX {
-                        namespace N {
-                            namespace G {
-                                namespace N {
-                                    namespace expression {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace mutable {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                    namespace _$ltype {
-                                        namespace N {
-                                            namespace O {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-        }
-        namespace D {
-            namespace Compilation__Unit {
-                namespace imports {
-                    namespace DX {
-                        type path = string;
-                    }
-                    type DX = {
-                        readonly 'path': string;
-                    };
-                }
-                type imports = pt.Dictionary<{
-                    readonly 'path': string;
-                }>;
-                type root__namespace = D.Namespace;
-            }
-            type Compilation__Unit = {
-                readonly 'imports': pt.Dictionary<{
-                    readonly 'path': string;
-                }>;
-                readonly 'root namespace': D.Namespace;
-            };
-            namespace Expression {
-                namespace array__literal {
-                    type A = D.Expression;
-                }
-                type array__literal = pt.Array<D.Expression>;
-                type block = D.Statement__Block;
-                namespace change__context {
-                    type new__context__selection = D.Expression;
-                    type sub__expression = D.Expression;
-                }
-                type change__context = {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub expression': D.Expression;
-                };
-                namespace dictionary__literal {
-                    type DX = D.Expression;
-                }
-                type dictionary__literal = pt.Dictionary<D.Expression>;
-                type _lfalse = null;
-                namespace _lfunction {
-                    type block = D.Statement__Block;
-                    namespace temp__signature__help {
-                        type has__additional__parameters = null;
-                        type has__no__additional__parameters = null;
-                        type typed = D.Function__Signature;
-                    }
-                    type temp__signature__help = ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                }
-                type _lfunction = {
-                    readonly 'block': D.Statement__Block;
-                    readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                };
-                namespace group__literal {
-                    type DX = D.Expression;
-                }
-                type group__literal = pt.Dictionary<D.Expression>;
-                type implement__me = string;
-                type not__set = null;
-                type null__literal = null;
-                type number__literal = number;
-                type panic = string;
-                namespace selection {
-                    namespace start {
-                        type context = null;
-                        type parameter = string;
-                        namespace variable {
-                            namespace _limport {
-                                type O = string;
-                            }
-                            type _limport = pt.OptionalValue<string>;
-                            namespace namespace__path {
-                                type A = string;
-                            }
-                            type namespace__path = pt.Array<string>;
-                            type variable = string;
-                        }
-                        type variable = {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        };
-                    }
-                    type start = ['context', null] | ['parameter', string] | [
-                        'variable',
-                        {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        }
-                    ];
-                    namespace tail {
-                        namespace A {
-                            namespace call {
-                                namespace _larguments {
-                                    type DX = D.Expression;
-                                }
-                                type _larguments = pt.Dictionary<D.Expression>;
-                                type context = D.Expression;
-                                type type__arguments = D.Type__Arguments;
-                            }
-                            type call = {
-                                readonly 'arguments': pt.Dictionary<D.Expression>;
-                                readonly 'context': D.Expression;
-                                readonly 'type arguments': D.Type__Arguments;
-                            };
-                            type member__selection = string;
-                        }
-                        type A = [
-                            'call',
-                            {
-                                readonly 'arguments': pt.Dictionary<D.Expression>;
-                                readonly 'context': D.Expression;
-                                readonly 'type arguments': D.Type__Arguments;
-                            }
-                        ] | ['member selection', string];
-                    }
-                    type tail = pt.Array<[
-                        'call',
-                        {
-                            readonly 'arguments': pt.Dictionary<D.Expression>;
-                            readonly 'context': D.Expression;
-                            readonly 'type arguments': D.Type__Arguments;
-                        }
-                    ] | ['member selection', string]>;
-                }
-                type selection = {
-                    readonly 'start': ['context', null] | ['parameter', string] | [
-                        'variable',
-                        {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        }
-                    ];
-                    readonly 'tail': pt.Array<[
-                        'call',
-                        {
-                            readonly 'arguments': pt.Dictionary<D.Expression>;
-                            readonly 'context': D.Expression;
-                            readonly 'type arguments': D.Type__Arguments;
-                        }
-                    ] | ['member selection', string]>;
-                };
-                type _lset = D.Expression;
-                namespace state__literal {
-                    type data = D.Expression;
-                    type state = string;
-                }
-                type state__literal = {
-                    readonly 'data': D.Expression;
-                    readonly 'state': string;
-                };
-                type string__literal = string;
-                namespace _lswitch {
-                    namespace cases {
-                        type DX = D.Expression;
-                    }
-                    type cases = pt.Dictionary<D.Expression>;
-                    namespace _ldefault {
-                        type O = D.Expression;
-                    }
-                    type _ldefault = pt.OptionalValue<D.Expression>;
-                    type select = D.Expression;
-                }
-                type _lswitch = {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                    readonly 'select': D.Expression;
-                };
-                namespace ternary__condition {
-                    type condition = D.Expression;
-                    type false__expression = D.Expression;
-                    type true__expression = D.Expression;
-                }
-                type ternary__condition = {
-                    readonly 'condition': D.Expression;
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                };
-                type _ltrue = null;
-            }
-            type Expression = ['array literal', pt.Array<D.Expression>] | ['block', D.Statement__Block] | [
-                'change context',
-                {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub expression': D.Expression;
-                }
-            ] | ['dictionary literal', pt.Dictionary<D.Expression>] | ['false', null] | [
-                'function',
-                {
-                    readonly 'block': D.Statement__Block;
-                    readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
-                }
-            ] | ['group literal', pt.Dictionary<D.Expression>] | ['implement me', string] | ['not set', null] | ['null literal', null] | ['number literal', number] | ['panic', string] | [
-                'selection',
-                {
-                    readonly 'start': ['context', null] | ['parameter', string] | [
-                        'variable',
-                        {
-                            readonly 'import': pt.OptionalValue<string>;
-                            readonly 'namespace path': pt.Array<string>;
-                            readonly 'variable': string;
-                        }
-                    ];
-                    readonly 'tail': pt.Array<[
-                        'call',
-                        {
-                            readonly 'arguments': pt.Dictionary<D.Expression>;
-                            readonly 'context': D.Expression;
-                            readonly 'type arguments': D.Type__Arguments;
-                        }
-                    ] | ['member selection', string]>;
-                }
-            ] | ['set', D.Expression] | [
-                'state literal',
-                {
-                    readonly 'data': D.Expression;
-                    readonly 'state': string;
-                }
-            ] | ['string literal', string] | [
-                'switch',
-                {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                    readonly 'select': D.Expression;
-                }
-            ] | [
-                'ternary condition',
-                {
-                    readonly 'condition': D.Expression;
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                }
-            ] | ['true', null];
-            namespace Function__Signature {
-                type context__parameter = D.Type;
-                namespace parameters {
-                    type DX = D.Type;
-                }
-                type parameters = pt.Dictionary<D.Type>;
-                namespace return__type {
-                    type O = D.Type;
-                }
-                type return__type = pt.OptionalValue<D.Type>;
-                type type__parameters = D.Type__Parameters;
-            }
-            type Function__Signature = {
-                readonly 'context parameter': D.Type;
-                readonly 'parameters': pt.Dictionary<D.Type>;
-                readonly 'return type': pt.OptionalValue<D.Type>;
-                readonly 'type parameters': D.Type__Parameters;
-            };
-            namespace Namespace {
-                namespace namespaces {
-                    type DX = D.Namespace;
-                }
-                type namespaces = pt.Dictionary<D.Namespace>;
-                namespace types {
-                    namespace DX {
-                        type _ltype = D.Type;
-                        type type__parameters = D.Type__Parameters;
-                    }
-                    type DX = {
-                        readonly 'type': D.Type;
-                        readonly 'type parameters': D.Type__Parameters;
-                    };
-                }
-                type types = pt.Dictionary<{
-                    readonly 'type': D.Type;
-                    readonly 'type parameters': D.Type__Parameters;
-                }>;
-                type variables = D.Variables;
-            }
-            type Namespace = {
-                readonly 'namespaces': pt.Dictionary<D.Namespace>;
-                readonly 'types': pt.Dictionary<{
-                    readonly 'type': D.Type;
-                    readonly 'type parameters': D.Type__Parameters;
-                }>;
-                readonly 'variables': D.Variables;
-            };
-            namespace Statement__Block {
-                namespace statements {
-                    namespace A {
-                        namespace assignment {
-                            type expression = D.Expression;
-                            type selection = D.Expression;
-                        }
-                        type assignment = {
-                            readonly 'expression': D.Expression;
-                            readonly 'selection': D.Expression;
-                        };
-                        namespace change__context {
-                            type new__context__selection = D.Expression;
-                            type sub__statement__block = D.Statement__Block;
-                        }
-                        type change__context = {
-                            readonly 'new context selection': D.Expression;
-                            readonly 'sub statement block': D.Statement__Block;
-                        };
-                        type debug = string;
-                        type expression = D.Expression;
-                        namespace _lif {
-                            type condition = D.Expression;
-                            namespace _lelse {
-                                type O = D.Statement__Block;
-                            }
-                            type _lelse = pt.OptionalValue<D.Statement__Block>;
-                            type if__block = D.Statement__Block;
-                        }
-                        type _lif = {
-                            readonly 'condition': D.Expression;
-                            readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'if block': D.Statement__Block;
-                        };
-                        namespace _lreturn {
-                            type expression = D.Expression;
-                        }
-                        type _lreturn = {
-                            readonly 'expression': D.Expression;
-                        };
-                        type sub__block = D.Statement__Block;
-                        namespace _lswitch {
-                            namespace cases {
-                                type DX = D.Statement__Block;
-                            }
-                            type cases = pt.Dictionary<D.Statement__Block>;
-                            namespace _ldefault {
-                                type O = D.Statement__Block;
-                            }
-                            type _ldefault = pt.OptionalValue<D.Statement__Block>;
-                            type select = D.Expression;
-                        }
-                        type _lswitch = {
-                            readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                            readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'select': D.Expression;
-                        };
-                    }
-                    type A = [
-                        'assignment',
-                        {
-                            readonly 'expression': D.Expression;
-                            readonly 'selection': D.Expression;
-                        }
-                    ] | [
-                        'change context',
-                        {
-                            readonly 'new context selection': D.Expression;
-                            readonly 'sub statement block': D.Statement__Block;
-                        }
-                    ] | ['debug', string] | ['expression', D.Expression] | [
-                        'if',
-                        {
-                            readonly 'condition': D.Expression;
-                            readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'if block': D.Statement__Block;
-                        }
-                    ] | [
-                        'return',
-                        {
-                            readonly 'expression': D.Expression;
-                        }
-                    ] | ['sub block', D.Statement__Block] | [
-                        'switch',
-                        {
-                            readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                            readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                            readonly 'select': D.Expression;
-                        }
-                    ];
-                }
-                type statements = pt.Array<[
-                    'assignment',
-                    {
-                        readonly 'expression': D.Expression;
-                        readonly 'selection': D.Expression;
-                    }
-                ] | [
-                    'change context',
-                    {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub statement block': D.Statement__Block;
-                    }
-                ] | ['debug', string] | ['expression', D.Expression] | [
-                    'if',
-                    {
-                        readonly 'condition': D.Expression;
-                        readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'if block': D.Statement__Block;
-                    }
-                ] | [
-                    'return',
-                    {
-                        readonly 'expression': D.Expression;
-                    }
-                ] | ['sub block', D.Statement__Block] | [
-                    'switch',
-                    {
-                        readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                        readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'select': D.Expression;
-                    }
-                ]>;
-                type variables = D.Variables;
-            }
-            type Statement__Block = {
-                readonly 'statements': pt.Array<[
-                    'assignment',
-                    {
-                        readonly 'expression': D.Expression;
-                        readonly 'selection': D.Expression;
-                    }
-                ] | [
-                    'change context',
-                    {
-                        readonly 'new context selection': D.Expression;
-                        readonly 'sub statement block': D.Statement__Block;
-                    }
-                ] | ['debug', string] | ['expression', D.Expression] | [
-                    'if',
-                    {
-                        readonly 'condition': D.Expression;
-                        readonly 'else': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'if block': D.Statement__Block;
-                    }
-                ] | [
-                    'return',
-                    {
-                        readonly 'expression': D.Expression;
-                    }
-                ] | ['sub block', D.Statement__Block] | [
-                    'switch',
-                    {
-                        readonly 'cases': pt.Dictionary<D.Statement__Block>;
-                        readonly 'default': pt.OptionalValue<D.Statement__Block>;
-                        readonly 'select': D.Expression;
-                    }
-                ]>;
-                readonly 'variables': D.Variables;
-            };
-            namespace Type {
-                type array = D.Type;
-                type _lboolean = null;
-                type dictionary = D.Type;
-                type _lfunction = D.Function__Signature;
-                namespace group {
-                    namespace members {
-                        type DX = D.Type;
-                    }
-                    type members = pt.Dictionary<D.Type>;
-                }
-                type group = {
-                    readonly 'members': pt.Dictionary<D.Type>;
-                };
-                type _lnull = null;
-                type _lnumber = null;
-                type optional = D.Type;
-                type parameter__selection = string;
-                type _lstring = null;
-                namespace tagged__union {
-                    type DX = D.Type;
-                }
-                type tagged__union = pt.Dictionary<D.Type>;
-                namespace type__selection {
-                    namespace _limport {
-                        type O = string;
-                    }
-                    type _limport = pt.OptionalValue<string>;
-                    namespace namespace__path {
-                        type A = string;
-                    }
-                    type namespace__path = pt.Array<string>;
-                    type _ltype = string;
-                    type type__arguments = D.Type__Arguments;
-                }
-                type type__selection = {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'type': string;
-                    readonly 'type arguments': D.Type__Arguments;
-                };
-            }
-            type Type = ['array', D.Type] | ['boolean', null] | ['dictionary', D.Type] | ['function', D.Function__Signature] | [
-                'group',
-                {
-                    readonly 'members': pt.Dictionary<D.Type>;
-                }
-            ] | ['null', null] | ['number', null] | ['optional', D.Type] | ['parameter selection', string] | ['string', null] | ['tagged union', pt.Dictionary<D.Type>] | [
-                'type selection',
-                {
-                    readonly 'import': pt.OptionalValue<string>;
-                    readonly 'namespace path': pt.Array<string>;
-                    readonly 'type': string;
-                    readonly 'type arguments': D.Type__Arguments;
-                }
-            ];
-            namespace Type__Arguments {
-                type DX = D.Type;
-            }
-            type Type__Arguments = pt.Dictionary<D.Type>;
-            namespace Type__Parameters {
-                type DX = null;
-            }
-            type Type__Parameters = pt.Dictionary<null>;
-            namespace Variables {
-                namespace DX {
-                    type expression = D.Expression;
-                    type mutable = boolean;
-                    namespace _ltype {
-                        type O = D.Type;
-                    }
-                    type _ltype = pt.OptionalValue<D.Type>;
-                }
-                type DX = {
-                    readonly 'expression': D.Expression;
-                    readonly 'mutable': boolean;
-                    readonly 'type': pt.OptionalValue<D.Type>;
-                };
-            }
-            type Variables = pt.Dictionary<{
-                readonly 'expression': D.Expression;
-                readonly 'mutable': boolean;
-                readonly 'type': pt.OptionalValue<D.Type>;
-            }>;
-        }
-        namespace I { }
-        namespace A { }
-    }
-}
-export declare namespace N { }
-export declare namespace D {
-    namespace Library2ParetoComparatorsData {
-        type library = G.cosmos.D.Library;
-    }
-    type Library2ParetoComparatorsData = {
-        readonly 'library': G.cosmos.D.Library;
-    };
-}
-export declare namespace I { }
-export declare namespace A {
-    type Library2ParetoComparators = ($: D.Library2ParetoComparatorsData) => G.pareto.D.Compilation__Unit;
-}