pareto 0.55.0 → 0.56.0

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

@@ -1801,28 +1801,37 @@ export declare namespace G {
                 namespace N {
                     namespace TU {
                         namespace N {
-                            namespace array_$_$literal {
+                            namespace flow {
                                 namespace N {
-                                    namespace A {
-                                        namespace N { }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace block {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace change_$_$context {
-                                namespace N {
-                                    namespace G {
+                                    namespace TU {
                                         namespace N {
-                                            namespace new_$_$context_$_$selection {
+                                            namespace block {
                                                 namespace N { }
                                                 namespace D { }
                                             }
-                                            namespace sub_$_$expression {
+                                            namespace change_$_$context {
+                                                namespace N {
+                                                    namespace G {
+                                                        namespace N {
+                                                            namespace new_$_$context_$_$selection {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                            namespace sub_$_$expression {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace implement_$_$me {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace panic {
                                                 namespace N { }
                                                 namespace D { }
                                             }
@@ -1832,43 +1841,229 @@ export declare namespace G {
                                 }
                                 namespace D { }
                             }
-                            namespace dictionary_$_$literal {
+                            namespace literal {
                                 namespace N {
-                                    namespace DX {
-                                        namespace N { }
+                                    namespace TU {
+                                        namespace N {
+                                            namespace array {
+                                                namespace N {
+                                                    namespace A {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace _$lboolean {
+                                                namespace N {
+                                                    namespace TU {
+                                                        namespace N {
+                                                            namespace _$lfalse {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                            namespace _$ltrue {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace dictionary {
+                                                namespace N {
+                                                    namespace DX {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace _$lfunction {
+                                                namespace N {
+                                                    namespace G {
+                                                        namespace N {
+                                                            namespace block {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                            namespace temp_$_$signature_$_$help {
+                                                                namespace N {
+                                                                    namespace TU {
+                                                                        namespace N {
+                                                                            namespace has_$_$additional_$_$parameters {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace has_$_$no_$_$additional_$_$parameters {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace typed {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace group {
+                                                namespace N {
+                                                    namespace DX {
+                                                        namespace N { }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace _$lnull {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace _$lnumber {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace optional {
+                                                namespace N {
+                                                    namespace TU {
+                                                        namespace N {
+                                                            namespace not_$_$set {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                            namespace _$lset {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                            namespace _$lstring {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace tagged_$_$union {
+                                                namespace N {
+                                                    namespace G {
+                                                        namespace N {
+                                                            namespace data {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                            namespace state {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
+                                                        }
+                                                        namespace D { }
+                                                    }
+                                                }
+                                                namespace D { }
+                                            }
+                                        }
                                         namespace D { }
                                     }
                                 }
                                 namespace D { }
                             }
-                            namespace _$lfalse {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lfunction {
+                            namespace map {
                                 namespace N {
                                     namespace G {
                                         namespace N {
-                                            namespace block {
+                                            namespace selection {
                                                 namespace N { }
                                                 namespace D { }
                                             }
-                                            namespace temp_$_$signature_$_$help {
+                                            namespace _$ltype {
                                                 namespace N {
                                                     namespace TU {
                                                         namespace N {
-                                                            namespace has_$_$additional_$_$parameters {
+                                                            namespace array {
                                                                 namespace N { }
                                                                 namespace D { }
                                                             }
-                                                            namespace has_$_$no_$_$additional_$_$parameters {
-                                                                namespace N { }
+                                                            namespace _$lboolean {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace false_$_$expression {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace true_$_$expression {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
                                                                 namespace D { }
                                                             }
-                                                            namespace typed {
+                                                            namespace dictionary {
                                                                 namespace N { }
                                                                 namespace D { }
                                                             }
+                                                            namespace optional {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace not_$_$set {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace _$lset {
+                                                                                namespace N { }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
+                                                            namespace tagged_$_$union {
+                                                                namespace N {
+                                                                    namespace G {
+                                                                        namespace N {
+                                                                            namespace cases {
+                                                                                namespace N {
+                                                                                    namespace DX {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                            namespace _$ldefault {
+                                                                                namespace N {
+                                                                                    namespace O {
+                                                                                        namespace N { }
+                                                                                        namespace D { }
+                                                                                    }
+                                                                                }
+                                                                                namespace D { }
+                                                                            }
+                                                                        }
+                                                                        namespace D { }
+                                                                    }
+                                                                }
+                                                                namespace D { }
+                                                            }
                                                         }
                                                         namespace D { }
                                                     }
@@ -1881,35 +2076,28 @@ export declare namespace G {
                                 }
                                 namespace D { }
                             }
-                            namespace group_$_$literal {
+                            namespace reduce {
                                 namespace N {
-                                    namespace DX {
-                                        namespace N { }
+                                    namespace G {
+                                        namespace N {
+                                            namespace callback {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace initial {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                            namespace selection {
+                                                namespace N { }
+                                                namespace D { }
+                                            }
+                                        }
                                         namespace D { }
                                     }
                                 }
                                 namespace D { }
                             }
-                            namespace implement_$_$me {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace not_$_$set {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace null_$_$literal {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace number_$_$literal {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace panic {
-                                namespace N { }
-                                namespace D { }
-                            }
                             namespace selection {
                                 namespace N {
                                     namespace G {
@@ -1926,6 +2114,10 @@ export declare namespace G {
                                                                 namespace N { }
                                                                 namespace D { }
                                                             }
+                                                            namespace seed {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
                                                             namespace variable {
                                                                 namespace N {
                                                                     namespace G {
@@ -2016,90 +2208,6 @@ export declare namespace G {
                                 }
                                 namespace D { }
                             }
-                            namespace _$lset {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace state_$_$literal {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace data {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace state {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace string_$_$literal {
-                                namespace N { }
-                                namespace D { }
-                            }
-                            namespace _$lswitch {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace cases {
-                                                namespace N {
-                                                    namespace DX {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace _$ldefault {
-                                                namespace N {
-                                                    namespace O {
-                                                        namespace N { }
-                                                        namespace D { }
-                                                    }
-                                                }
-                                                namespace D { }
-                                            }
-                                            namespace select {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace ternary_$_$condition {
-                                namespace N {
-                                    namespace G {
-                                        namespace N {
-                                            namespace condition {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace false_$_$expression {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                            namespace true_$_$expression {
-                                                namespace N { }
-                                                namespace D { }
-                                            }
-                                        }
-                                        namespace D { }
-                                    }
-                                }
-                                namespace D { }
-                            }
-                            namespace _$ltrue {
-                                namespace N { }
-                                namespace D { }
-                            }
                         }
                         namespace D { }
                     }
@@ -2521,50 +2629,186 @@ export declare namespace G {
                 readonly 'root namespace': D.Namespace;
             };
             namespace Expression {
-                namespace array__literal {
-                    type A = D.Expression;
-                }
-                type array__literal = pt.Array<D.Expression>;
-                type block = D.Statement__Block;
-                namespace change__context {
-                    type new__context__selection = D.Expression;
-                    type sub__expression = D.Expression;
-                }
-                type change__context = {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub expression': D.Expression;
-                };
-                namespace dictionary__literal {
-                    type DX = D.Expression;
-                }
-                type dictionary__literal = pt.Dictionary<D.Expression>;
-                type _lfalse = null;
-                namespace _lfunction {
+                namespace flow {
                     type block = D.Statement__Block;
-                    namespace temp__signature__help {
-                        type has__additional__parameters = null;
-                        type has__no__additional__parameters = null;
-                        type typed = D.Function__Signature;
+                    namespace change__context {
+                        type new__context__selection = D.Expression;
+                        type sub__expression = D.Expression;
+                    }
+                    type change__context = {
+                        readonly 'new context selection': D.Expression;
+                        readonly 'sub expression': D.Expression;
+                    };
+                    type implement__me = string;
+                    type panic = string;
+                }
+                type flow = ['block', D.Statement__Block] | [
+                    'change context',
+                    {
+                        readonly 'new context selection': D.Expression;
+                        readonly 'sub expression': D.Expression;
+                    }
+                ] | ['implement me', string] | ['panic', string];
+                namespace literal {
+                    namespace array {
+                        type A = D.Expression;
+                    }
+                    type array = pt.Array<D.Expression>;
+                    namespace _lboolean {
+                        type _lfalse = null;
+                        type _ltrue = null;
+                    }
+                    type _lboolean = ['false', null] | ['true', null];
+                    namespace dictionary {
+                        type DX = D.Expression;
+                    }
+                    type dictionary = pt.Dictionary<D.Expression>;
+                    namespace _lfunction {
+                        type block = D.Statement__Block;
+                        namespace temp__signature__help {
+                            type has__additional__parameters = null;
+                            type has__no__additional__parameters = null;
+                            type typed = D.Function__Signature;
+                        }
+                        type temp__signature__help = ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                    }
+                    type _lfunction = {
+                        readonly 'block': D.Statement__Block;
+                        readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                    };
+                    namespace group {
+                        type DX = D.Expression;
+                    }
+                    type group = pt.Dictionary<D.Expression>;
+                    type _lnull = null;
+                    type _lnumber = number;
+                    namespace optional {
+                        type not__set = null;
+                        type _lset = D.Expression;
+                    }
+                    type optional = ['not set', null] | ['set', D.Expression];
+                    type _lstring = string;
+                    namespace tagged__union {
+                        type data = D.Expression;
+                        type state = string;
+                    }
+                    type tagged__union = {
+                        readonly 'data': D.Expression;
+                        readonly 'state': string;
+                    };
+                }
+                type literal = ['array', pt.Array<D.Expression>] | [
+                    'boolean',
+                    ['false', null] | ['true', null]
+                ] | ['dictionary', pt.Dictionary<D.Expression>] | [
+                    'function',
+                    {
+                        readonly 'block': D.Statement__Block;
+                        readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                    }
+                ] | ['group', pt.Dictionary<D.Expression>] | ['null', null] | ['number', number] | [
+                    'optional',
+                    ['not set', null] | ['set', D.Expression]
+                ] | ['string', string] | [
+                    'tagged union',
+                    {
+                        readonly 'data': D.Expression;
+                        readonly 'state': string;
+                    }
+                ];
+                namespace map {
+                    type selection = D.Expression;
+                    namespace _ltype {
+                        type array = D.Expression;
+                        namespace _lboolean {
+                            type false__expression = D.Expression;
+                            type true__expression = D.Expression;
+                        }
+                        type _lboolean = {
+                            readonly 'false expression': D.Expression;
+                            readonly 'true expression': D.Expression;
+                        };
+                        type dictionary = D.Expression;
+                        namespace optional {
+                            type not__set = D.Expression;
+                            type _lset = D.Expression;
+                        }
+                        type optional = {
+                            readonly 'not set': D.Expression;
+                            readonly 'set': D.Expression;
+                        };
+                        namespace tagged__union {
+                            namespace cases {
+                                type DX = D.Expression;
+                            }
+                            type cases = pt.Dictionary<D.Expression>;
+                            namespace _ldefault {
+                                type O = D.Expression;
+                            }
+                            type _ldefault = pt.OptionalValue<D.Expression>;
+                        }
+                        type tagged__union = {
+                            readonly 'cases': pt.Dictionary<D.Expression>;
+                            readonly 'default': pt.OptionalValue<D.Expression>;
+                        };
                     }
-                    type temp__signature__help = ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                    type _ltype = ['array', D.Expression] | [
+                        'boolean',
+                        {
+                            readonly 'false expression': D.Expression;
+                            readonly 'true expression': D.Expression;
+                        }
+                    ] | ['dictionary', D.Expression] | [
+                        'optional',
+                        {
+                            readonly 'not set': D.Expression;
+                            readonly 'set': D.Expression;
+                        }
+                    ] | [
+                        'tagged union',
+                        {
+                            readonly 'cases': pt.Dictionary<D.Expression>;
+                            readonly 'default': pt.OptionalValue<D.Expression>;
+                        }
+                    ];
                 }
-                type _lfunction = {
-                    readonly 'block': D.Statement__Block;
-                    readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                type map = {
+                    readonly 'selection': D.Expression;
+                    readonly 'type': ['array', D.Expression] | [
+                        'boolean',
+                        {
+                            readonly 'false expression': D.Expression;
+                            readonly 'true expression': D.Expression;
+                        }
+                    ] | ['dictionary', D.Expression] | [
+                        'optional',
+                        {
+                            readonly 'not set': D.Expression;
+                            readonly 'set': D.Expression;
+                        }
+                    ] | [
+                        'tagged union',
+                        {
+                            readonly 'cases': pt.Dictionary<D.Expression>;
+                            readonly 'default': pt.OptionalValue<D.Expression>;
+                        }
+                    ];
+                };
+                namespace reduce {
+                    type callback = D.Expression;
+                    type initial = D.Expression;
+                    type selection = D.Expression;
+                }
+                type reduce = {
+                    readonly 'callback': D.Expression;
+                    readonly 'initial': D.Expression;
+                    readonly 'selection': D.Expression;
                 };
-                namespace group__literal {
-                    type DX = D.Expression;
-                }
-                type group__literal = pt.Dictionary<D.Expression>;
-                type implement__me = string;
-                type not__set = null;
-                type null__literal = null;
-                type number__literal = number;
-                type panic = string;
                 namespace selection {
                     namespace start {
                         type context = null;
                         type parameter = string;
+                        type seed = null;
                         namespace variable {
                             namespace _limport {
                                 type O = string;
@@ -2582,7 +2826,7 @@ export declare namespace G {
                             readonly 'variable': string;
                         };
                     }
-                    type start = ['context', null] | ['parameter', string] | [
+                    type start = ['context', null] | ['parameter', string] | ['seed', null] | [
                         'variable',
                         {
                             readonly 'import': pt.OptionalValue<string>;
@@ -2626,7 +2870,7 @@ export declare namespace G {
                     ] | ['member selection', string]>;
                 }
                 type selection = {
-                    readonly 'start': ['context', null] | ['parameter', string] | [
+                    readonly 'start': ['context', null] | ['parameter', string] | ['seed', null] | [
                         'variable',
                         {
                             readonly 'import': pt.OptionalValue<string>;
@@ -2643,60 +2887,72 @@ export declare namespace G {
                         }
                     ] | ['member selection', string]>;
                 };
-                type _lset = D.Expression;
-                namespace state__literal {
-                    type data = D.Expression;
-                    type state = string;
-                }
-                type state__literal = {
-                    readonly 'data': D.Expression;
-                    readonly 'state': string;
-                };
-                type string__literal = string;
-                namespace _lswitch {
-                    namespace cases {
-                        type DX = D.Expression;
+            }
+            type Expression = [
+                'flow',
+                ['block', D.Statement__Block] | [
+                    'change context',
+                    {
+                        readonly 'new context selection': D.Expression;
+                        readonly 'sub expression': D.Expression;
                     }
-                    type cases = pt.Dictionary<D.Expression>;
-                    namespace _ldefault {
-                        type O = D.Expression;
+                ] | ['implement me', string] | ['panic', string]
+            ] | [
+                'literal',
+                ['array', pt.Array<D.Expression>] | [
+                    'boolean',
+                    ['false', null] | ['true', null]
+                ] | ['dictionary', pt.Dictionary<D.Expression>] | [
+                    'function',
+                    {
+                        readonly 'block': D.Statement__Block;
+                        readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                    }
+                ] | ['group', pt.Dictionary<D.Expression>] | ['null', null] | ['number', number] | [
+                    'optional',
+                    ['not set', null] | ['set', D.Expression]
+                ] | ['string', string] | [
+                    'tagged union',
+                    {
+                        readonly 'data': D.Expression;
+                        readonly 'state': string;
                     }
-                    type _ldefault = pt.OptionalValue<D.Expression>;
-                    type select = D.Expression;
-                }
-                type _lswitch = {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                    readonly 'select': D.Expression;
-                };
-                namespace ternary__condition {
-                    type condition = D.Expression;
-                    type false__expression = D.Expression;
-                    type true__expression = D.Expression;
-                }
-                type ternary__condition = {
-                    readonly 'condition': D.Expression;
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                };
-                type _ltrue = null;
-            }
-            type Expression = ['array literal', pt.Array<D.Expression>] | ['block', D.Statement__Block] | [
-                'change context',
+                ]
+            ] | [
+                'map',
                 {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub expression': D.Expression;
+                    readonly 'selection': D.Expression;
+                    readonly 'type': ['array', D.Expression] | [
+                        'boolean',
+                        {
+                            readonly 'false expression': D.Expression;
+                            readonly 'true expression': D.Expression;
+                        }
+                    ] | ['dictionary', D.Expression] | [
+                        'optional',
+                        {
+                            readonly 'not set': D.Expression;
+                            readonly 'set': D.Expression;
+                        }
+                    ] | [
+                        'tagged union',
+                        {
+                            readonly 'cases': pt.Dictionary<D.Expression>;
+                            readonly 'default': pt.OptionalValue<D.Expression>;
+                        }
+                    ];
                 }
-            ] | ['dictionary literal', pt.Dictionary<D.Expression>] | ['false', null] | [
-                'function',
+            ] | [
+                'reduce',
                 {
-                    readonly 'block': D.Statement__Block;
-                    readonly 'temp signature help': ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                    readonly 'callback': D.Expression;
+                    readonly 'initial': D.Expression;
+                    readonly 'selection': D.Expression;
                 }
-            ] | ['group literal', pt.Dictionary<D.Expression>] | ['implement me', string] | ['not set', null] | ['null literal', null] | ['number literal', number] | ['panic', string] | [
+            ] | [
                 'selection',
                 {
-                    readonly 'start': ['context', null] | ['parameter', string] | [
+                    readonly 'start': ['context', null] | ['parameter', string] | ['seed', null] | [
                         'variable',
                         {
                             readonly 'import': pt.OptionalValue<string>;
@@ -2713,27 +2969,7 @@ export declare namespace G {
                         }
                     ] | ['member selection', string]>;
                 }
-            ] | ['set', D.Expression] | [
-                'state literal',
-                {
-                    readonly 'data': D.Expression;
-                    readonly 'state': string;
-                }
-            ] | ['string literal', string] | [
-                'switch',
-                {
-                    readonly 'cases': pt.Dictionary<D.Expression>;
-                    readonly 'default': pt.OptionalValue<D.Expression>;
-                    readonly 'select': D.Expression;
-                }
-            ] | [
-                'ternary condition',
-                {
-                    readonly 'condition': D.Expression;
-                    readonly 'false expression': D.Expression;
-                    readonly 'true expression': D.Expression;
-                }
-            ] | ['true', null];
+            ];
             namespace Function__Signature {
                 type context__parameter = D.Type;
                 namespace parameters {