pareto 0.55.0 → 0.57.0

package/auto.dist/public/{pareto__2__typescript → modules/pareto2typescript}/auto.provided_interface_glossary.d.ts

@@ -12,6 +12,18 @@ export declare namespace G {
                 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;
@@ -21,13 +33,42 @@ export declare namespace G {
             }
             type Line = pt.Array<['indent', D.Block] | ['snippet', string]>;
             namespace Lines {
-                type A = string;
+                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 Lines = pt.Array<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 I { }
         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;
         }
     }
     namespace pareto {
@@ -70,28 +111,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 { }
                                             }
@@ -101,43 +151,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 { }
                                                     }
@@ -150,35 +386,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 {
@@ -195,6 +424,10 @@ export declare namespace G {
                                                                 namespace N { }
                                                                 namespace D { }
                                                             }
+                                                            namespace seed {
+                                                                namespace N { }
+                                                                namespace D { }
+                                                            }
                                                             namespace variable {
                                                                 namespace N {
                                                                     namespace G {
@@ -285,90 +518,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 { }
                     }
@@ -790,50 +939,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;
+                namespace flow {
+                    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;
+                    };
+                    type implement__me = string;
+                    type panic = string;
                 }
-                type change__context = {
-                    readonly 'new context selection': D.Expression;
-                    readonly 'sub expression': D.Expression;
-                };
-                namespace dictionary__literal {
-                    type DX = D.Expression;
+                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 dictionary__literal = pt.Dictionary<D.Expression>;
-                type _lfalse = null;
-                namespace _lfunction {
-                    type block = D.Statement__Block;
-                    namespace temp__signature__help {
-                        type has__additional__parameters = null;
-                        type has__no__additional__parameters = null;
-                        type typed = D.Function__Signature;
+                type 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 temp__signature__help = ['has additional parameters', null] | ['has no additional parameters', null] | ['typed', D.Function__Signature];
+                ];
+                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 _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 group__literal {
-                    type DX = D.Expression;
+                namespace reduce {
+                    type callback = D.Expression;
+                    type initial = D.Expression;
+                    type selection = 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;
+                type reduce = {
+                    readonly 'callback': D.Expression;
+                    readonly 'initial': D.Expression;
+                    readonly 'selection': D.Expression;
+                };
                 namespace selection {
                     namespace start {
                         type context = null;
                         type parameter = string;
+                        type seed = null;
                         namespace variable {
                             namespace _limport {
                                 type O = string;
@@ -851,7 +1136,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>;
@@ -895,7 +1180,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>;
@@ -912,60 +1197,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];
                     }
-                    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',
+                ] | ['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;
+                    }
+                ]
+            ] | [
+                '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>;
@@ -982,27 +1279,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 {
@@ -1301,10 +1578,6 @@ export declare namespace G {
 }
 export declare namespace N { }
 export declare namespace D {
-    namespace Lines {
-        type A = string;
-    }
-    type Lines = pt.Array<string>;
     namespace Serialize__CompilationUnit__Data {
         type compilation__unit = G.pareto.D.Compilation__Unit;
     }
@@ -1314,5 +1587,5 @@ export declare namespace D {
 }
 export declare namespace I { }
 export declare namespace A {
-    type SerializeCompilationUnit = ($: D.Serialize__CompilationUnit__Data) => D.Lines;
+    type SerializeCompilationUnit = ($: D.Serialize__CompilationUnit__Data) => G.fp.D.Indented__Lines;
 }