npm - pareto - Versions diffs - 0.71.0 → 0.73.0 - Mend

pareto 0.71.0 → 0.73.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (155) hide show

package/auto.dist/public/modules/cosmos_type_system_2_typescript_intermediate/auto.provided_interface_glossary.d.ts DELETED Viewed

@@ -1,2228 +0,0 @@
-import * as pt from 'pareto-core-types';
-export declare namespace G {
-    namespace _r_in {
-        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 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 _$_r_$_module {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                            namespace _$_r_$_type {
-                                                                                namespace N {
-                                                                                    namespace TU {
-                                                                                        namespace N {
-                                                                                            namespace library_$__$_dependency {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                            namespace _$_r_$_private {
-                                                                                                namespace N { }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                            namespace _$_r_$_public {
-                                                                                                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 _$_r_$_import {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N {
-                                                            namespace glossary {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace local {
-                                                namespace N { }
-                                                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 _$_r_$_interface {
-                                                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 Composite_$__$_Transformations {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace higher_$__$_glossaries {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace types {
-                                                        namespace N {
-                                                            namespace DX {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace lower_$__$_glossaries {
-                                                                                namespace N {
-                                                                                    namespace DX {
-                                                                                        namespace N {
-                                                                                            namespace G {
-                                                                                                namespace N {
-                                                                                                    namespace target_$__$_types {
-                                                                                                        namespace N {
-                                                                                                            namespace DX {
-                                                                                                                namespace N { }
-                                                                                                                namespace D { }
-                                                                                                            }
-                                                                                                        }
-                                                                                                        namespace D { }
-                                                                                                    }
-                                                                                                }
-                                                                                                namespace D { }
-                                                                                            }
-                                                                                        }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Data_$__$_Glossary {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            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 root {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Data_$__$_Or_$__$_Synchronous_$__$_Interface {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace data {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_interface {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Data_$__$_Type {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace _$_r_$_boolean {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace component {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace dictionary {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace group {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace integer {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace link {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace forward {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace target {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace value {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace list {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace nothing {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace optional {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace state_$__$_group {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace text {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Data_$__$_Type_$__$_Reference {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace _$_r_$_type {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace type_$__$_arguments {
-                                namespace N { }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Data_$__$_Type_$__$_Specifier {
-                namespace N {
-                    namespace TU {
-                        namespace N {
-                            namespace glossary_$__$_parameterXX {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_type {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace context {
-                                                namespace N {
-                                                    namespace TU {
-                                                        namespace N {
-                                                            namespace _$_r_$_import {
-                                                                namespace N {
-                                                                    namespace G {
-                                                                        namespace N {
-                                                                            namespace glossary {
-                                                                                namespace N { }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                            namespace local {
-                                                                namespace N { }
-                                                                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 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 _$_r_$_type {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace asynchronous_$__$_function {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$_r_$_in {
-                                                                                        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 _$_r_$_interface {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace procedure {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$_r_$_in {
-                                                                                        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 _$_r_$_in {
-                                                                                        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 data_$__$_glossary {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace interface_$__$_types {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N {
-                                            namespace G {
-                                                namespace N {
-                                                    namespace parameters {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace _$_r_$_type {
-                                                        namespace N {
-                                                            namespace TU {
-                                                                namespace N {
-                                                                    namespace asynchronous {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$_r_$_interface {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                    namespace synchronous {
-                                                                        namespace N {
-                                                                            namespace G {
-                                                                                namespace N {
-                                                                                    namespace _$_r_$_interface {
-                                                                                        namespace N { }
-                                                                                        namespace D { }
-                                                                                    }
-                                                                                }
-                                                                                namespace D { }
-                                                                            }
-                                                                        }
-                                                                        namespace D { }
-                                                                    }
-                                                                }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                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 _$_r_$_private {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_public {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace _$_r_$_type {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace composite {
-                                                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 pure {
-                                                                namespace N { }
-                                                                namespace D { }
-                                                            }
-                                                        }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace primitive {
-                                                namespace N {
-                                                    namespace G {
-                                                        namespace N { }
-                                                        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 G {
-                                                namespace N {
-                                                    namespace description {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                    namespace glossary {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace modules {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace transformations {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace enrich {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$_r_$_yield {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        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 _$_r_$_type {
-                                                        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 D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Synchronous_$__$_Interface_$__$_Reference {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace context {
-                                namespace N {
-                                    namespace TU {
-                                        namespace N {
-                                            namespace _$_r_$_import {
-                                                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 _$_r_$_interface {
-                                                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 Transformation {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace parameters {
-                                namespace N {
-                                    namespace DX {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                        }
-                        namespace D { }
-                    }
-                }
-                namespace D { }
-            }
-            namespace Transformations {
-                namespace N {
-                    namespace G {
-                        namespace N {
-                            namespace atom {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace _$_r_$_boolean {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace dictionary {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace integer {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace list {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace text {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace composite {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace external_$__$_libraries {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace local {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace glossary {
-                                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 {
-                        type definition = D.Algorithm__Type__Reference;
-                        namespace dependencies {
-                            namespace DX {
-                                type algorithm__type = D.Algorithm__Type__Reference;
-                                type _r_module = string;
-                                namespace _r_type {
-                                    type library__dependency = string;
-                                    type _r_private = null;
-                                    type _r_public = null;
-                                    type sibling = null;
-                                }
-                                type _r_type = ['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 '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 '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 '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.Data__Type__Specifier;
-            }
-            type Arguments = pt.Dictionary<D.Data__Type__Specifier>;
-            namespace Asynchronous__Interface__Reference {
-                namespace context {
-                    namespace _r_import {
-                        type glossary = D.Glossary__Reference;
-                    }
-                    type _r_import = {
-                        readonly 'glossary': D.Glossary__Reference;
-                    };
-                    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.Data__Type__Specifier;
-                    }
-                    type data = pt.OptionalValue<D.Data__Type__Specifier>;
-                    namespace _r_interface {
-                        type O = D.Asynchronous__Interface__Type;
-                    }
-                    type _r_interface = pt.OptionalValue<D.Asynchronous__Interface__Type>;
-                }
-                type method = {
-                    readonly 'data': pt.OptionalValue<D.Data__Type__Specifier>;
-                    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.Data__Type__Specifier>;
-                    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 Composite__Transformations {
-                namespace higher__glossaries {
-                    namespace DX {
-                        namespace types {
-                            namespace DX {
-                                namespace lower__glossaries {
-                                    namespace DX {
-                                        namespace target__types {
-                                            type DX = D.Transformation;
-                                        }
-                                        type target__types = pt.Dictionary<D.Transformation>;
-                                    }
-                                    type DX = {
-                                        readonly 'target types': pt.Dictionary<D.Transformation>;
-                                    };
-                                }
-                                type lower__glossaries = pt.Dictionary<{
-                                    readonly 'target types': pt.Dictionary<D.Transformation>;
-                                }>;
-                            }
-                            type DX = {
-                                readonly 'lower glossaries': pt.Dictionary<{
-                                    readonly 'target types': pt.Dictionary<D.Transformation>;
-                                }>;
-                            };
-                        }
-                        type types = pt.Dictionary<{
-                            readonly 'lower glossaries': pt.Dictionary<{
-                                readonly 'target types': pt.Dictionary<D.Transformation>;
-                            }>;
-                        }>;
-                    }
-                    type DX = {
-                        readonly 'types': pt.Dictionary<{
-                            readonly 'lower glossaries': pt.Dictionary<{
-                                readonly 'target types': pt.Dictionary<D.Transformation>;
-                            }>;
-                        }>;
-                    };
-                }
-                type higher__glossaries = pt.Dictionary<{
-                    readonly 'types': pt.Dictionary<{
-                        readonly 'lower glossaries': pt.Dictionary<{
-                            readonly 'target types': pt.Dictionary<D.Transformation>;
-                        }>;
-                    }>;
-                }>;
-            }
-            type Composite__Transformations = {
-                readonly 'higher glossaries': pt.Dictionary<{
-                    readonly 'types': pt.Dictionary<{
-                        readonly 'lower glossaries': pt.Dictionary<{
-                            readonly 'target types': pt.Dictionary<D.Transformation>;
-                        }>;
-                    }>;
-                }>;
-            };
-            namespace Data__Glossary {
-                type glossary__parameters = D.Parameters;
-                namespace imports {
-                    namespace DX {
-                        type glossary = D.Data__Glossary;
-                        type type__arguments = D.Arguments;
-                    }
-                    type DX = {
-                        readonly 'glossary': D.Data__Glossary;
-                        readonly 'type arguments': D.Arguments;
-                    };
-                }
-                type imports = pt.Dictionary<{
-                    readonly 'glossary': D.Data__Glossary;
-                    readonly 'type arguments': D.Arguments;
-                }>;
-                type root = D.Namespace;
-            }
-            type Data__Glossary = {
-                readonly 'glossary parameters': D.Parameters;
-                readonly 'imports': pt.Dictionary<{
-                    readonly 'glossary': D.Data__Glossary;
-                    readonly 'type arguments': D.Arguments;
-                }>;
-                readonly 'root': D.Namespace;
-            };
-            namespace Data__Or__Synchronous__Interface {
-                type data = D.Data__Type__Specifier;
-                type _r_interface = D.Synchronous__Interface__Reference;
-            }
-            type Data__Or__Synchronous__Interface = ['data', D.Data__Type__Specifier] | ['interface', D.Synchronous__Interface__Reference];
-            namespace Data__Type {
-                type _r_boolean = null;
-                type component = D.Data__Type__Specifier;
-                type dictionary = D.Data__Type;
-                namespace group {
-                    type DX = D.Data__Type;
-                }
-                type group = pt.Dictionary<D.Data__Type>;
-                type integer = null;
-                namespace link {
-                    type forward = boolean;
-                    type target = D.Data__Type__Specifier;
-                    type value = D.Data__Type;
-                }
-                type link = {
-                    readonly 'forward': boolean;
-                    readonly 'target': D.Data__Type__Specifier;
-                    readonly 'value': D.Data__Type;
-                };
-                type list = D.Data__Type;
-                type nothing = null;
-                type optional = D.Data__Type;
-                namespace state__group {
-                    type DX = D.Data__Type;
-                }
-                type state__group = pt.Dictionary<D.Data__Type>;
-                type text = null;
-            }
-            type Data__Type = ['boolean', null] | ['component', D.Data__Type__Specifier] | ['dictionary', D.Data__Type] | ['group', pt.Dictionary<D.Data__Type>] | ['integer', null] | [
-                'link',
-                {
-                    readonly 'forward': boolean;
-                    readonly 'target': D.Data__Type__Specifier;
-                    readonly 'value': D.Data__Type;
-                }
-            ] | ['list', D.Data__Type] | ['nothing', null] | ['optional', D.Data__Type] | ['state group', pt.Dictionary<D.Data__Type>] | ['text', null];
-            namespace Data__Type__Reference {
-                type _r_type = string;
-                type type__arguments = D.Arguments;
-            }
-            type Data__Type__Reference = {
-                readonly 'type': string;
-                readonly 'type arguments': D.Arguments;
-            };
-            namespace Data__Type__Specifier {
-                type glossary__parameterXX = string;
-                namespace _r_type {
-                    namespace context {
-                        namespace _r_import {
-                            type glossary = D.Glossary__Reference;
-                        }
-                        type _r_import = {
-                            readonly 'glossary': D.Glossary__Reference;
-                        };
-                        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 _r_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 type__parameterXX = string;
-            }
-            type Data__Type__Specifier = ['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 Glossary {
-                namespace algorithm__types {
-                    namespace DX {
-                        type parameters = D.Parameters;
-                        namespace _r_type {
-                            namespace asynchronous__function {
-                                type _r_in = D.Data__Type__Specifier;
-                                type out = D.Data__Type__Specifier;
-                            }
-                            type asynchronous__function = {
-                                readonly 'in': D.Data__Type__Specifier;
-                                readonly 'out': D.Data__Type__Specifier;
-                            };
-                            namespace interface__initializer {
-                                namespace downstreams {
-                                    type DX = D.Asynchronous__Interface__Reference;
-                                }
-                                type downstreams = pt.Dictionary<D.Asynchronous__Interface__Reference>;
-                                type _r_interface = D.Asynchronous__Interface__Reference;
-                            }
-                            type interface__initializer = {
-                                readonly 'downstreams': pt.Dictionary<D.Asynchronous__Interface__Reference>;
-                                readonly 'interface': D.Asynchronous__Interface__Reference;
-                            };
-                            namespace procedure {
-                                type _r_in = 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.Data__Type__Specifier;
-                            }
-                            type resource__initializer = {
-                                readonly 'consumer': D.Asynchronous__Interface__Reference;
-                                readonly 'request': D.Data__Type__Specifier;
-                            };
-                            namespace synchronous__function {
-                                type _r_in = D.Data__Or__Synchronous__Interface;
-                                type out = D.Data__Type__Specifier;
-                            }
-                            type synchronous__function = {
-                                readonly 'in': D.Data__Or__Synchronous__Interface;
-                                readonly 'out': D.Data__Type__Specifier;
-                            };
-                        }
-                        type _r_type = [
-                            'asynchronous function',
-                            {
-                                readonly 'in': D.Data__Type__Specifier;
-                                readonly 'out': D.Data__Type__Specifier;
-                            }
-                        ] | [
-                            '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.Data__Type__Specifier;
-                            }
-                        ] | [
-                            'synchronous function',
-                            {
-                                readonly 'in': D.Data__Or__Synchronous__Interface;
-                                readonly 'out': D.Data__Type__Specifier;
-                            }
-                        ];
-                    }
-                    type DX = {
-                        readonly 'parameters': D.Parameters;
-                        readonly 'type': [
-                            'asynchronous function',
-                            {
-                                readonly 'in': D.Data__Type__Specifier;
-                                readonly 'out': D.Data__Type__Specifier;
-                            }
-                        ] | [
-                            '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.Data__Type__Specifier;
-                            }
-                        ] | [
-                            'synchronous function',
-                            {
-                                readonly 'in': D.Data__Or__Synchronous__Interface;
-                                readonly 'out': D.Data__Type__Specifier;
-                            }
-                        ];
-                    };
-                }
-                type algorithm__types = pt.Dictionary<{
-                    readonly 'parameters': D.Parameters;
-                    readonly 'type': [
-                        'asynchronous function',
-                        {
-                            readonly 'in': D.Data__Type__Specifier;
-                            readonly 'out': D.Data__Type__Specifier;
-                        }
-                    ] | [
-                        '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.Data__Type__Specifier;
-                        }
-                    ] | [
-                        'synchronous function',
-                        {
-                            readonly 'in': D.Data__Or__Synchronous__Interface;
-                            readonly 'out': D.Data__Type__Specifier;
-                        }
-                    ];
-                }>;
-                type data__glossary = D.Data__Glossary;
-                namespace interface__types {
-                    namespace DX {
-                        type parameters = D.Parameters;
-                        namespace _r_type {
-                            namespace asynchronous {
-                                type _r_interface = D.Asynchronous__Interface__Type;
-                            }
-                            type asynchronous = {
-                                readonly 'interface': D.Asynchronous__Interface__Type;
-                            };
-                            namespace synchronous {
-                                type _r_interface = D.Synchronous__Interface__Type;
-                            }
-                            type synchronous = {
-                                readonly 'interface': D.Synchronous__Interface__Type;
-                            };
-                        }
-                        type _r_type = [
-                            '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 Glossary = {
-                readonly 'algorithm types': pt.Dictionary<{
-                    readonly 'parameters': D.Parameters;
-                    readonly 'type': [
-                        'asynchronous function',
-                        {
-                            readonly 'in': D.Data__Type__Specifier;
-                            readonly 'out': D.Data__Type__Specifier;
-                        }
-                    ] | [
-                        '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.Data__Type__Specifier;
-                        }
-                    ] | [
-                        'synchronous function',
-                        {
-                            readonly 'in': D.Data__Or__Synchronous__Interface;
-                            readonly 'out': D.Data__Type__Specifier;
-                        }
-                    ];
-                }>;
-                readonly 'data glossary': D.Data__Glossary;
-                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;
-                        }
-                    ];
-                }>;
-            };
-            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 _r_private = D.Module__Set;
-                    type _r_public = D.Module__Set;
-                }
-                type module__sets = {
-                    readonly 'private': D.Module__Set;
-                    readonly 'public': D.Module__Set;
-                };
-                namespace _r_type {
-                    namespace composite {
-                        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 = boolean;
-                    }
-                    type composite = {
-                        readonly 'dependencies': pt.Dictionary<{
-                            readonly 'library': D.Library;
-                            readonly 'version': string;
-                        }>;
-                        readonly 'pure': boolean;
-                    };
-                    namespace primitive { }
-                    type primitive = null;
-                }
-                type _r_type = [
-                    'composite',
-                    {
-                        readonly 'dependencies': pt.Dictionary<{
-                            readonly 'library': D.Library;
-                            readonly 'version': string;
-                        }>;
-                        readonly 'pure': boolean;
-                    }
-                ] | ['primitive', null];
-            }
-            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': [
-                    'composite',
-                    {
-                        readonly 'dependencies': pt.Dictionary<{
-                            readonly 'library': D.Library;
-                            readonly 'version': string;
-                        }>;
-                        readonly 'pure': boolean;
-                    }
-                ] | ['primitive', null];
-            };
-            namespace Module__Set {
-                namespace glossaries {
-                    namespace DX {
-                        type description = string;
-                        type glossary = D.Data__Glossary;
-                    }
-                    type DX = {
-                        readonly 'description': string;
-                        readonly 'glossary': D.Data__Glossary;
-                    };
-                }
-                type glossaries = pt.Dictionary<{
-                    readonly 'description': string;
-                    readonly 'glossary': D.Data__Glossary;
-                }>;
-                namespace modules {
-                    type DX = D.API;
-                }
-                type modules = pt.Dictionary<D.API>;
-                namespace transformations {
-                    namespace enrich {
-                        type DX = D.Transformations;
-                    }
-                    type enrich = pt.Dictionary<D.Transformations>;
-                    namespace _r_yield {
-                        type DX = D.Transformations;
-                    }
-                    type _r_yield = pt.Dictionary<D.Transformations>;
-                }
-                type transformations = {
-                    readonly 'enrich': pt.Dictionary<D.Transformations>;
-                    readonly 'yield': pt.Dictionary<D.Transformations>;
-                };
-            }
-            type Module__Set = {
-                readonly 'glossaries': pt.Dictionary<{
-                    readonly 'description': string;
-                    readonly 'glossary': D.Data__Glossary;
-                }>;
-                readonly 'modules': pt.Dictionary<D.API>;
-                readonly 'transformations': {
-                    readonly 'enrich': pt.Dictionary<D.Transformations>;
-                    readonly 'yield': pt.Dictionary<D.Transformations>;
-                };
-            };
-            namespace Namespace {
-                namespace data__types {
-                    namespace DX {
-                        type parameters = D.Parameters;
-                        type _r_type = 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 {
-                type DX = null;
-            }
-            type Parameters = pt.Dictionary<null>;
-            namespace Synchronous__Interface__Reference {
-                namespace context {
-                    namespace _r_import {
-                        type glossary = D.Glossary__Reference;
-                        type interfaceXX = string;
-                    }
-                    type _r_import = {
-                        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.Data__Type__Specifier;
-                    }
-                    type data = pt.OptionalValue<D.Data__Type__Specifier>;
-                    namespace _r_interface {
-                        type O = D.Synchronous__Interface__Type;
-                    }
-                    type _r_interface = pt.OptionalValue<D.Synchronous__Interface__Type>;
-                }
-                type method = {
-                    readonly 'data': pt.OptionalValue<D.Data__Type__Specifier>;
-                    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.Data__Type__Specifier>;
-                    readonly 'interface': pt.OptionalValue<D.Synchronous__Interface__Type>;
-                }
-            ] | ['reference', D.Synchronous__Interface__Reference];
-            namespace Transformation {
-                namespace parameters {
-                    type DX = D.Data__Type__Reference;
-                }
-                type parameters = pt.Dictionary<D.Data__Type__Reference>;
-            }
-            type Transformation = {
-                readonly 'parameters': pt.Dictionary<D.Data__Type__Reference>;
-            };
-            namespace Transformations {
-                namespace atom {
-                    namespace _r_boolean {
-                        type DX = D.Transformation;
-                    }
-                    type _r_boolean = pt.Dictionary<D.Transformation>;
-                    namespace dictionary {
-                        type DX = D.Transformation;
-                    }
-                    type dictionary = pt.Dictionary<D.Transformation>;
-                    namespace integer {
-                        type DX = D.Transformation;
-                    }
-                    type integer = pt.Dictionary<D.Transformation>;
-                    namespace list {
-                        type DX = D.Transformation;
-                    }
-                    type list = pt.Dictionary<D.Transformation>;
-                    namespace text {
-                        type DX = D.Transformation;
-                    }
-                    type text = pt.Dictionary<D.Transformation>;
-                }
-                type atom = {
-                    readonly 'boolean': pt.Dictionary<D.Transformation>;
-                    readonly 'dictionary': pt.Dictionary<D.Transformation>;
-                    readonly 'integer': pt.Dictionary<D.Transformation>;
-                    readonly 'list': pt.Dictionary<D.Transformation>;
-                    readonly 'text': pt.Dictionary<D.Transformation>;
-                };
-                namespace composite {
-                    namespace external__libraries {
-                        type DX = D.Composite__Transformations;
-                    }
-                    type external__libraries = pt.Dictionary<D.Composite__Transformations>;
-                    type local = D.Composite__Transformations;
-                }
-                type composite = {
-                    readonly 'external libraries': pt.Dictionary<D.Composite__Transformations>;
-                    readonly 'local': D.Composite__Transformations;
-                };
-                type glossary = D.Data__Glossary;
-            }
-            type Transformations = {
-                readonly 'atom': {
-                    readonly 'boolean': pt.Dictionary<D.Transformation>;
-                    readonly 'dictionary': pt.Dictionary<D.Transformation>;
-                    readonly 'integer': pt.Dictionary<D.Transformation>;
-                    readonly 'list': pt.Dictionary<D.Transformation>;
-                    readonly 'text': pt.Dictionary<D.Transformation>;
-                };
-                readonly 'composite': {
-                    readonly 'external libraries': pt.Dictionary<D.Composite__Transformations>;
-                    readonly 'local': D.Composite__Transformations;
-                };
-                readonly 'glossary': D.Data__Glossary;
-            };
-        }
-    }
-    namespace out {
-        namespace G { }
-        namespace N { }
-        namespace D {
-            namespace Block {
-                namespace A {
-                    namespace block__dictionary {
-                        type DX = D.Block;
-                    }
-                    type block__dictionary = pt.Dictionary<D.Block>;
-                    type line = string;
-                    type nested__line = D.Line;
-                }
-                type A = ['block dictionary', pt.Dictionary<D.Block>] | ['line', string] | ['nested line', D.Line];
-            }
-            type Block = pt.Array<['block dictionary', pt.Dictionary<D.Block>] | ['line', string] | ['nested line', D.Line]>;
-            namespace Line {
-                namespace A {
-                    type apostrophed__string = string;
-                    type backticked__string = string;
-                    type identifier = string;
-                    type indent = D.Block;
-                    namespace line__dictionary {
-                        namespace dictionary {
-                            type DX = D.Line;
-                        }
-                        type dictionary = pt.Dictionary<D.Line>;
-                        type if__empty = D.Line;
-                        namespace if__not__empty {
-                            type add__commas__in__between = boolean;
-                            type prefix = D.Line;
-                            type suffix = D.Line;
-                        }
-                        type if__not__empty = {
-                            readonly 'add commas in between': boolean;
-                            readonly 'prefix': D.Line;
-                            readonly 'suffix': D.Line;
-                        };
-                    }
-                    type line__dictionary = {
-                        readonly 'dictionary': pt.Dictionary<D.Line>;
-                        readonly 'if empty': D.Line;
-                        readonly 'if not empty': {
-                            readonly 'add commas in between': boolean;
-                            readonly 'prefix': D.Line;
-                            readonly 'suffix': D.Line;
-                        };
-                    };
-                    type quoted__string = string;
-                    type snippet = string;
-                }
-                type A = ['apostrophed string', string] | ['backticked string', string] | ['identifier', string] | ['indent', D.Block] | [
-                    'line dictionary',
-                    {
-                        readonly 'dictionary': pt.Dictionary<D.Line>;
-                        readonly 'if empty': D.Line;
-                        readonly 'if not empty': {
-                            readonly 'add commas in between': boolean;
-                            readonly 'prefix': D.Line;
-                            readonly 'suffix': D.Line;
-                        };
-                    }
-                ] | ['quoted string', string] | ['snippet', string];
-            }
-            type Line = pt.Array<['apostrophed string', string] | ['backticked string', string] | ['identifier', string] | ['indent', D.Block] | [
-                'line dictionary',
-                {
-                    readonly 'dictionary': pt.Dictionary<D.Line>;
-                    readonly 'if empty': D.Line;
-                    readonly 'if not empty': {
-                        readonly 'add commas in between': boolean;
-                        readonly 'prefix': D.Line;
-                        readonly 'suffix': D.Line;
-                    };
-                }
-            ] | ['quoted string', string] | ['snippet', string]>;
-            namespace Lines {
-                namespace A {
-                    type indentation = number;
-                    type text = string;
-                }
-                type A = {
-                    readonly 'indentation': number;
-                    readonly 'text': string;
-                };
-            }
-            type Lines = pt.Array<{
-                readonly 'indentation': number;
-                readonly 'text': string;
-            }>;
-        }
-    }
-}
-export declare namespace N { }
-export declare namespace D { }
-export declare namespace I { }
-export declare namespace A {
-    type Map__Data__Glossary__2__Block = ($: G._r_in.D.Data__Glossary) => G.out.D.Block;
-}