pareto 0.57.0 → 0.58.0

package/auto.dist/public/modules/alan__light__serialize/auto.provided_interface_glossary.d.ts

@@ -0,0 +1,705 @@
+import * as pt from 'pareto-core-types';
+export declare namespace G {
+    namespace alan {
+        namespace G { }
+        namespace N {
+            namespace Node {
+                namespace N {
+                    namespace G {
+                        namespace N {
+                            namespace properties {
+                                namespace N {
+                                    namespace DX {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N {
+                                                    namespace _$ltype {
+                                                        namespace N {
+                                                            namespace TU {
+                                                                namespace N {
+                                                                    namespace collection {
+                                                                        namespace N {
+                                                                            namespace G {
+                                                                                namespace N {
+                                                                                    namespace key {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                    namespace node {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                    namespace group {
+                                                                        namespace N {
+                                                                            namespace G {
+                                                                                namespace N {
+                                                                                    namespace node {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                    namespace state_$_$group {
+                                                                        namespace N {
+                                                                            namespace G {
+                                                                                namespace N {
+                                                                                    namespace states {
+                                                                                        namespace N {
+                                                                                            namespace DX {
+                                                                                                namespace N {
+                                                                                                    namespace G {
+                                                                                                        namespace N {
+                                                                                                            namespace constraints {
+                                                                                                                namespace N {
+                                                                                                                    namespace DX {
+                                                                                                                        namespace N {
+                                                                                                                            namespace G {
+                                                                                                                                namespace N {
+                                                                                                                                    namespace path {
+                                                                                                                                        namespace N { }
+                                                                                                                                        namespace D { }
+                                                                                                                                    }
+                                                                                                                                }
+                                                                                                                                namespace D { }
+                                                                                                                            }
+                                                                                                                        }
+                                                                                                                        namespace D { }
+                                                                                                                    }
+                                                                                                                }
+                                                                                                                namespace D { }
+                                                                                                            }
+                                                                                                            namespace node {
+                                                                                                                namespace N { }
+                                                                                                                namespace D { }
+                                                                                                            }
+                                                                                                        }
+                                                                                                        namespace D { }
+                                                                                                    }
+                                                                                                }
+                                                                                                namespace D { }
+                                                                                            }
+                                                                                        }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                    namespace text {
+                                                                        namespace N {
+                                                                            namespace G {
+                                                                                namespace N {
+                                                                                    namespace constraint {
+                                                                                        namespace N {
+                                                                                            namespace O {
+                                                                                                namespace N {
+                                                                                                    namespace G {
+                                                                                                        namespace N {
+                                                                                                            namespace dictionary {
+                                                                                                                namespace N { }
+                                                                                                                namespace D { }
+                                                                                                            }
+                                                                                                            namespace path {
+                                                                                                                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 Path {
+                namespace N {
+                    namespace G {
+                        namespace N {
+                            namespace context {
+                                namespace N {
+                                    namespace TU {
+                                        namespace N {
+                                            namespace sibling {
+                                                namespace N {
+                                                    namespace G {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace state_$_$constraint {
+                                                namespace N {
+                                                    namespace G {
+                                                        namespace N {
+                                                            namespace name {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                            namespace selection_$_$steps {
+                                namespace N {
+                                    namespace A {
+                                        namespace N {
+                                            namespace TU {
+                                                namespace N {
+                                                    namespace group {
+                                                        namespace N {
+                                                            namespace G {
+                                                                namespace N {
+                                                                    namespace name {
+                                                                        namespace N { }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                    namespace reference {
+                                                        namespace N {
+                                                            namespace G {
+                                                                namespace N {
+                                                                    namespace name {
+                                                                        namespace N { }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                    namespace state_$_$constraint {
+                                                        namespace N {
+                                                            namespace G {
+                                                                namespace N {
+                                                                    namespace name {
+                                                                        namespace N { }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                            namespace up_$_$steps {
+                                namespace N {
+                                    namespace A {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+            namespace Root {
+                namespace N {
+                    namespace G {
+                        namespace N {
+                            namespace numerical_$_$types {
+                                namespace N {
+                                    namespace DX {
+                                        namespace N {
+                                            namespace G {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
+                                        namespace D { }
+                                    }
+                                }
+                                namespace D { }
+                            }
+                            namespace root {
+                                namespace N { }
+                                namespace D { }
+                            }
+                        }
+                        namespace D { }
+                    }
+                }
+                namespace D { }
+            }
+        }
+        namespace D {
+            namespace Node {
+                namespace properties {
+                    namespace DX {
+                        namespace _ltype {
+                            namespace collection {
+                                type key = string;
+                                type node = D.Node;
+                            }
+                            type collection = {
+                                readonly 'key': string;
+                                readonly 'node': D.Node;
+                            };
+                            namespace group {
+                                type node = D.Node;
+                            }
+                            type group = {
+                                readonly 'node': D.Node;
+                            };
+                            namespace state__group {
+                                namespace states {
+                                    namespace DX {
+                                        namespace constraints {
+                                            namespace DX {
+                                                type path = D.Path;
+                                            }
+                                            type DX = {
+                                                readonly 'path': D.Path;
+                                            };
+                                        }
+                                        type constraints = pt.Dictionary<{
+                                            readonly 'path': D.Path;
+                                        }>;
+                                        type node = D.Node;
+                                    }
+                                    type DX = {
+                                        readonly 'constraints': pt.Dictionary<{
+                                            readonly 'path': D.Path;
+                                        }>;
+                                        readonly 'node': D.Node;
+                                    };
+                                }
+                                type states = pt.Dictionary<{
+                                    readonly 'constraints': pt.Dictionary<{
+                                        readonly 'path': D.Path;
+                                    }>;
+                                    readonly 'node': D.Node;
+                                }>;
+                            }
+                            type state__group = {
+                                readonly 'states': pt.Dictionary<{
+                                    readonly 'constraints': pt.Dictionary<{
+                                        readonly 'path': D.Path;
+                                    }>;
+                                    readonly 'node': D.Node;
+                                }>;
+                            };
+                            namespace text {
+                                namespace constraint {
+                                    namespace O {
+                                        type dictionary = string;
+                                        type path = D.Path;
+                                    }
+                                    type O = {
+                                        readonly 'dictionary': string;
+                                        readonly 'path': D.Path;
+                                    };
+                                }
+                                type constraint = pt.OptionalValue<{
+                                    readonly 'dictionary': string;
+                                    readonly 'path': D.Path;
+                                }>;
+                            }
+                            type text = {
+                                readonly 'constraint': pt.OptionalValue<{
+                                    readonly 'dictionary': string;
+                                    readonly 'path': D.Path;
+                                }>;
+                            };
+                        }
+                        type _ltype = [
+                            'collection',
+                            {
+                                readonly 'key': string;
+                                readonly 'node': D.Node;
+                            }
+                        ] | [
+                            'group',
+                            {
+                                readonly 'node': D.Node;
+                            }
+                        ] | [
+                            'state group',
+                            {
+                                readonly 'states': pt.Dictionary<{
+                                    readonly 'constraints': pt.Dictionary<{
+                                        readonly 'path': D.Path;
+                                    }>;
+                                    readonly 'node': D.Node;
+                                }>;
+                            }
+                        ] | [
+                            'text',
+                            {
+                                readonly 'constraint': pt.OptionalValue<{
+                                    readonly 'dictionary': string;
+                                    readonly 'path': D.Path;
+                                }>;
+                            }
+                        ];
+                    }
+                    type DX = {
+                        readonly 'type': [
+                            'collection',
+                            {
+                                readonly 'key': string;
+                                readonly 'node': D.Node;
+                            }
+                        ] | [
+                            'group',
+                            {
+                                readonly 'node': D.Node;
+                            }
+                        ] | [
+                            'state group',
+                            {
+                                readonly 'states': pt.Dictionary<{
+                                    readonly 'constraints': pt.Dictionary<{
+                                        readonly 'path': D.Path;
+                                    }>;
+                                    readonly 'node': D.Node;
+                                }>;
+                            }
+                        ] | [
+                            'text',
+                            {
+                                readonly 'constraint': pt.OptionalValue<{
+                                    readonly 'dictionary': string;
+                                    readonly 'path': D.Path;
+                                }>;
+                            }
+                        ];
+                    };
+                }
+                type properties = pt.Dictionary<{
+                    readonly 'type': [
+                        'collection',
+                        {
+                            readonly 'key': string;
+                            readonly 'node': D.Node;
+                        }
+                    ] | [
+                        'group',
+                        {
+                            readonly 'node': D.Node;
+                        }
+                    ] | [
+                        'state group',
+                        {
+                            readonly 'states': pt.Dictionary<{
+                                readonly 'constraints': pt.Dictionary<{
+                                    readonly 'path': D.Path;
+                                }>;
+                                readonly 'node': D.Node;
+                            }>;
+                        }
+                    ] | [
+                        'text',
+                        {
+                            readonly 'constraint': pt.OptionalValue<{
+                                readonly 'dictionary': string;
+                                readonly 'path': D.Path;
+                            }>;
+                        }
+                    ];
+                }>;
+            }
+            type Node = {
+                readonly 'properties': pt.Dictionary<{
+                    readonly 'type': [
+                        'collection',
+                        {
+                            readonly 'key': string;
+                            readonly 'node': D.Node;
+                        }
+                    ] | [
+                        'group',
+                        {
+                            readonly 'node': D.Node;
+                        }
+                    ] | [
+                        'state group',
+                        {
+                            readonly 'states': pt.Dictionary<{
+                                readonly 'constraints': pt.Dictionary<{
+                                    readonly 'path': D.Path;
+                                }>;
+                                readonly 'node': D.Node;
+                            }>;
+                        }
+                    ] | [
+                        'text',
+                        {
+                            readonly 'constraint': pt.OptionalValue<{
+                                readonly 'dictionary': string;
+                                readonly 'path': D.Path;
+                            }>;
+                        }
+                    ];
+                }>;
+            };
+            namespace Path {
+                namespace context {
+                    namespace sibling { }
+                    type sibling = null;
+                    namespace state__constraint {
+                        type name = string;
+                    }
+                    type state__constraint = {
+                        readonly 'name': string;
+                    };
+                }
+                type context = ['sibling', null] | [
+                    'state constraint',
+                    {
+                        readonly 'name': string;
+                    }
+                ];
+                namespace selection__steps {
+                    namespace A {
+                        namespace group {
+                            type name = string;
+                        }
+                        type group = {
+                            readonly 'name': string;
+                        };
+                        namespace reference {
+                            type name = string;
+                        }
+                        type reference = {
+                            readonly 'name': string;
+                        };
+                        namespace state__constraint {
+                            type name = string;
+                        }
+                        type state__constraint = {
+                            readonly 'name': string;
+                        };
+                    }
+                    type A = [
+                        'group',
+                        {
+                            readonly 'name': string;
+                        }
+                    ] | [
+                        'reference',
+                        {
+                            readonly 'name': string;
+                        }
+                    ] | [
+                        'state constraint',
+                        {
+                            readonly 'name': string;
+                        }
+                    ];
+                }
+                type selection__steps = pt.Array<[
+                    'group',
+                    {
+                        readonly 'name': string;
+                    }
+                ] | [
+                    'reference',
+                    {
+                        readonly 'name': string;
+                    }
+                ] | [
+                    'state constraint',
+                    {
+                        readonly 'name': string;
+                    }
+                ]>;
+                namespace up__steps {
+                    namespace A { }
+                    type A = null;
+                }
+                type up__steps = pt.Array<null>;
+            }
+            type Path = {
+                readonly 'context': ['sibling', null] | [
+                    'state constraint',
+                    {
+                        readonly 'name': string;
+                    }
+                ];
+                readonly 'selection steps': pt.Array<[
+                    'group',
+                    {
+                        readonly 'name': string;
+                    }
+                ] | [
+                    'reference',
+                    {
+                        readonly 'name': string;
+                    }
+                ] | [
+                    'state constraint',
+                    {
+                        readonly 'name': string;
+                    }
+                ]>;
+                readonly 'up steps': pt.Array<null>;
+            };
+            namespace Root {
+                namespace numerical__types {
+                    namespace DX { }
+                    type DX = null;
+                }
+                type numerical__types = pt.Dictionary<null>;
+                type root = D.Node;
+            }
+            type Root = {
+                readonly 'numerical types': pt.Dictionary<null>;
+                readonly 'root': D.Node;
+            };
+        }
+        namespace I { }
+        namespace A { }
+    }
+    namespace fp {
+        namespace G { }
+        namespace N { }
+        namespace D {
+            namespace Block {
+                namespace A {
+                    type line = string;
+                    type nested__line = D.Line;
+                }
+                type A = ['line', string] | ['nested line', D.Line];
+            }
+            type Block = pt.Array<['line', string] | ['nested line', D.Line]>;
+            namespace IndentData {
+                type indentation = string;
+                type lines = D.Lines;
+            }
+            type IndentData = {
+                readonly 'indentation': string;
+                readonly 'lines': D.Lines;
+            };
+            namespace Indented__Lines {
+                type A = string;
+            }
+            type Indented__Lines = pt.Array<string>;
+            namespace Line {
+                namespace A {
+                    type indent = D.Block;
+                    type snippet = string;
+                }
+                type A = ['indent', D.Block] | ['snippet', string];
+            }
+            type Line = pt.Array<['indent', D.Block] | ['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;
+            }>;
+            namespace SerializeData {
+                type block = D.Block;
+                type indentation = string;
+            }
+            type SerializeData = {
+                readonly 'block': D.Block;
+                readonly 'indentation': string;
+            };
+            type String = string;
+        }
+        namespace I {
+            type Indented__Lines = {
+                'data': ($: D.String) => void;
+                'end': () => void;
+            };
+            type Lines = ($: D.Lines) => void;
+        }
+        namespace A {
+            type Indent = ($: D.IndentData) => D.Indented__Lines;
+            type Serialize = ($: D.Block) => D.Lines;
+            type Stream = ($is: {
+                readonly 'handler': I.Indented__Lines;
+            }) => I.Lines;
+        }
+    }
+}
+export declare namespace N { }
+export declare namespace D {
+    type String = string;
+}
+export declare namespace I { }
+export declare namespace A {
+    type Serialize = ($: G.alan.D.Root) => G.fp.D.Indented__Lines;
+}