pareto 0.58.0 → 0.60.0

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

@@ -1,705 +0,0 @@
-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;
-}