pareto 0.80.74 → 0.80.76

package/dist/modules/pareto_new/schemas/schema_reference/transformers/typescript_light.js

@@ -9,11 +9,31 @@ export const Schema_Reference = ($) => ({
     'delimiter': ['quote', null],
     'value': p_.from.state($).decide(($) => {
         switch ($[0]) {
-            case 'child': return p_.option($, ($) => "../modules/" + ser_path.Name($.module) + "/schemas/" + ser_path.Name($.schema) + "/schema.js");
-            case 'external': return p_.option($, ($) => ser_path.Name($.package) + "/" + ser_path.Name($.schema));
-            case 'sibling': return p_.option($, ($) => "../../" + ser_path.Name($) + "/schema.js");
+            // case 'child': return p_.option($, ($) => "../modules/" + ser_path.Name($.module) + "/schemas/" + ser_path.Name($.schema) + "/schema.js")
+            case 'external': return p_.option($, ($) => ser_path.No_Space_Name($.package) + "/modules/" + ser_path.No_Space_Name($.module) + "/schemas/" + ser_path.No_Space_Name($.schema) + "/schema");
+            case 'sibling': return p_.option($, ($) => "../../" + ser_path.No_Space_Name($) + "/schema.js");
             default: return p_.exhaustive($[0]);
         }
     })
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXNjcmlwdF9saWdodC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3NyYy9tb2R1bGVzL3BhcmV0b19uZXcvc2NoZW1hcy9zY2hlbWFfcmVmZXJlbmNlL3RyYW5zZm9ybWVycy90eXBlc2NyaXB0X2xpZ2h0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0seUJBQXlCLENBQUE7QUFVN0MsT0FBTyxLQUFLLElBQUksTUFBTSxjQUFjLENBQUE7QUFDcEMsT0FBTyxLQUFLLEtBQUssTUFBTSxpRUFBaUUsQ0FBQTtBQUV4RixZQUFZO0FBQ1osT0FBTyxLQUFLLEVBQUUsTUFBTSw0RUFBNEUsQ0FBQTtBQUVoRyxjQUFjO0FBQ2QsT0FBTyxLQUFLLFFBQVEsTUFBTSw2RUFBNkUsQ0FBQTtBQUV2RyxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBa0MsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLENBQUM7SUFDbkUsV0FBVyxFQUFFLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQztJQUM1QixPQUFPLEVBQUUsRUFBRSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUMsTUFBTSxDQUM1QixDQUFDLENBQUMsRUFBRSxFQUFFO1FBQ0YsUUFBUSxDQUFDLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUNYLEtBQUssT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsYUFBYSxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLE1BQU0sQ0FBQyxHQUFHLFdBQVcsR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsR0FBRyxZQUFZLENBQUMsQ0FBQTtZQUN4SSxLQUFLLFVBQVUsQ0FBQyxDQUFDLE9BQU8sRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEVBQUUsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLE9BQU8sQ0FBQyxHQUFHLEdBQUcsR0FBRyxRQUFRLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFBO1lBQ3JHLEtBQUssU0FBUyxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUMsTUFBTSxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsUUFBUSxHQUFHLFFBQVEsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEdBQUcsWUFBWSxDQUFDLENBQUE7WUFDdEYsT0FBTyxDQUFDLENBQUMsT0FBTyxFQUFFLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFBO1FBQ3ZDLENBQUM7SUFDTCxDQUFDLENBQ0o7Q0FDSixDQUFDLENBQUEifQ==
+export const Type_Reference = ($, $p) => sh.t.type_reference($p.schema, p_.literal.segmented_list([
+    p_.literal.list([
+        sh.identifier_escaped($.type)
+    ]),
+]), p_.literal.list([]));
+export const Value_Reference = ($, $p) => sh.t.type_reference($p.schema, p_.literal.segmented_list([
+    p_.literal.list([
+        sh.identifier_escaped($.type)
+    ]),
+    p_.from.list($['subselection']).map(($) => p_.from.state($).decide(($) => {
+        switch ($[0]) {
+            case 'dictionary': return p_.option($, ($) => sh.identifier_raw("D"));
+            case 'group': return p_.option($, ($) => sh.identifier_escaped($.property));
+            case 'list': return p_.option($, ($) => sh.identifier_raw("L"));
+            case 'optional': return p_.option($, ($) => sh.identifier_raw("O"));
+            case 'state': return p_.option($, ($) => sh.identifier_escaped($.option));
+            default: return p_.exhaustive($[0]);
+        }
+    })),
+]), p_.literal.list([]));
+//# sourceMappingURL=data:application/json;base64,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

package/dist/modules/pareto_new/schemas/transformer/schema.d.ts

@@ -1,40 +1,395 @@
 import * as p_ from 'pareto-core/schema';
-import * as i_value_reference from "../value_reference/schema.js";
-import * as i_type_reference from "../type_reference/schema.js";
-import * as i_schema_reference from "../schema_reference/schema.js";
-export type Root = {
-    'development mode': boolean;
-    'target schema': Root.target_schema;
-    'parameters schema': Root.parameters_schema;
-    'declarations': p_.Dictionary<Root.declarations_D>;
-    'dependencies': p_.Dictionary<Root.dependencies_D>;
-    'implementations': Root.implementations;
+declare namespace Value_Selection_Tail_ {
+    type L = string;
+}
+type Value_Selection_Tail_ = p_.List<Value_Selection_Tail_.L>;
+declare namespace Select_Value_ {
+    namespace call {
+        namespace scope {
+            namespace external {
+                type transformer = string;
+                type function_ = string;
+            }
+            type external = {
+                readonly 'transformer': external.transformer;
+                readonly 'function': external.function_;
+            };
+            namespace local {
+                type function_ = string;
+            }
+            type local = {
+                readonly 'function': local.function_;
+            };
+        }
+        type scope = readonly ['external', scope.external] | readonly ['local', scope.local];
+        type context = Select_Value_;
+        namespace arguments_ {
+            type omit = null;
+            type pass_through = null;
+            type initialize = Expression_;
+        }
+        type arguments_ = readonly ['omit', arguments_.omit] | readonly ['pass through', arguments_.pass_through] | readonly ['initialize', arguments_.initialize];
+        type tail = Value_Selection_Tail_;
+    }
+    type call = {
+        readonly 'scope': call.scope;
+        readonly 'context': call.context;
+        readonly 'arguments': call.arguments_;
+        readonly 'tail': call.tail;
+    };
+    namespace context_value {
+        type tail = Value_Selection_Tail_;
+    }
+    type context_value = {
+        readonly 'tail': context_value.tail;
+    };
+}
+type Select_Value_ = readonly ['call', Select_Value_.call] | readonly ['context value', Select_Value_.context_value];
+declare namespace Value_Reference_ {
+    type type_ = string;
+    namespace subselection {
+        namespace L {
+            type dictionary = null;
+            namespace group {
+                type property = string;
+            }
+            type group = {
+                readonly 'property': group.property;
+            };
+            type list = null;
+            type optional = null;
+            namespace state {
+                type option = string;
+            }
+            type state = {
+                readonly 'option': state.option;
+            };
+        }
+        type L = readonly ['dictionary', L.dictionary] | readonly ['group', L.group] | readonly ['list', L.list] | readonly ['optional', L.optional] | readonly ['state', L.state];
+    }
+    type subselection = p_.List<subselection.L>;
+}
+type Value_Reference_ = {
+    readonly 'type': Value_Reference_.type_;
+    readonly 'subselection': Value_Reference_.subselection;
 };
-export declare namespace Root {
-    type target_schema = i_schema_reference.Schema_Reference;
-    type parameters_schema = p_.Optional_Value<i_schema_reference.Schema_Reference>;
-    type declarations_D = {
-        'target value': i_value_reference.Value_Reference;
-        'parameter': p_.Optional_Value<i_type_reference.Type_Reference>;
+declare namespace Expression_ {
+    namespace change_context {
+        type select = Select_Value_;
+        type callback = Expression_;
+    }
+    type change_context = {
+        readonly 'select': change_context.select;
+        readonly 'callback': change_context.callback;
+    };
+    namespace convert {
+        type select = Select_Value_;
+        namespace type_ {
+            namespace component {
+                namespace transform {
+                    namespace scope {
+                        namespace external {
+                            type transformer = string;
+                            type function_ = string;
+                        }
+                        type external = {
+                            readonly 'transformer': external.transformer;
+                            readonly 'function': external.function_;
+                        };
+                        namespace local {
+                            type function_ = string;
+                        }
+                        type local = {
+                            readonly 'function': local.function_;
+                        };
+                    }
+                    type scope = readonly ['external', scope.external] | readonly ['local', scope.local];
+                    namespace arguments_ {
+                        type omit = null;
+                        type pass_through = null;
+                        namespace initialize {
+                            type expression = Expression_;
+                        }
+                        type initialize = {
+                            readonly 'expression': initialize.expression;
+                        };
+                    }
+                    type arguments_ = readonly ['omit', arguments_.omit] | readonly ['pass through', arguments_.pass_through] | readonly ['initialize', arguments_.initialize];
+                }
+                type transform = {
+                    readonly 'scope': transform.scope;
+                    readonly 'arguments': transform.arguments_;
+                };
+            }
+            type component = readonly ['transform', component.transform];
+            namespace dictionary {
+                namespace map {
+                    type on_entry = Expression_;
+                }
+                type map = {
+                    readonly 'on entry': map.on_entry;
+                };
+            }
+            type dictionary = readonly ['map', dictionary.map];
+            namespace list {
+                namespace map {
+                    type on_item = Expression_;
+                }
+                type map = {
+                    readonly 'on item': map.on_item;
+                };
+            }
+            type list = readonly ['map', list.map];
+            namespace optional {
+                namespace decide {
+                    namespace temp_return_type {
+                        type O = Value_Reference_;
+                    }
+                    type temp_return_type = p_.Optional_Value<temp_return_type.O>;
+                    type on_set = Expression_;
+                    type on_not_set = Expression_;
+                }
+                type decide = {
+                    readonly 'temp return type': decide.temp_return_type;
+                    readonly 'on set': decide.on_set;
+                    readonly 'on not set': decide.on_not_set;
+                };
+                namespace map {
+                    type on_set = Expression_;
+                }
+                type map = {
+                    readonly 'on set': map.on_set;
+                };
+            }
+            type optional = readonly ['decide', optional.decide] | readonly ['map', optional.map];
+            namespace state {
+                namespace decide {
+                    namespace temp_return_type {
+                        type O = Value_Reference_;
+                    }
+                    type temp_return_type = p_.Optional_Value<temp_return_type.O>;
+                    namespace options {
+                        type D = Expression_;
+                    }
+                    type options = p_.Dictionary<options.D>;
+                }
+                type decide = {
+                    readonly 'temp return type': decide.temp_return_type;
+                    readonly 'options': decide.options;
+                };
+            }
+            type state = readonly ['decide', state.decide];
+        }
+        type type_ = readonly ['component', type_.component] | readonly ['dictionary', type_.dictionary] | readonly ['list', type_.list] | readonly ['optional', type_.optional] | readonly ['state', type_.state];
+    }
+    type convert = {
+        readonly 'select': convert.select;
+        readonly 'type': convert.type_;
     };
-    type dependencies_D = {
-        'location': ['this module', null] | [
-            'external module',
-            {
-                'module': string;
-            }
-        ];
-        'source schema': string;
-        'target schema': string;
+    namespace implement_me {
+        type remark = string;
+    }
+    type implement_me = {
+        readonly 'remark': implement_me.remark;
     };
-    type implementations = p_.Dictionary<Root.implementations_D>;
-    type implementations_D = {
-        'expression': Expression;
+    namespace initialize {
+        namespace boolean_ {
+            type false_ = null;
+            type true_ = null;
+        }
+        type boolean_ = readonly ['false', boolean_.false_] | readonly ['true', boolean_.true_];
+        namespace dictionary {
+            type D = Expression_;
+        }
+        type dictionary = p_.Dictionary<dictionary.D>;
+        namespace group {
+            type D = Expression_;
+        }
+        type group = p_.Dictionary<group.D>;
+        namespace list {
+            type L = Expression_;
+        }
+        type list = p_.List<list.L>;
+        type nothing = null;
+        namespace number_ {
+            type natural = number;
+            type integer = number;
+        }
+        type number_ = readonly ['natural', number_.natural] | readonly ['integer', number_.integer];
+        namespace optional {
+            type not_set = null;
+            type set_ = Expression_;
+        }
+        type optional = readonly ['not set', optional.not_set] | readonly ['set', optional.set_];
+        type reference = string;
+        namespace state {
+            type option = string;
+            type data = Expression_;
+        }
+        type state = {
+            readonly 'option': state.option;
+            readonly 'data': state.data;
+        };
+        namespace text {
+            type literal = string;
+            namespace serialize {
+                namespace scope {
+                    namespace external {
+                        type serializer = string;
+                        type function_ = string;
+                    }
+                    type external = {
+                        readonly 'serializer': external.serializer;
+                        readonly 'function': external.function_;
+                    };
+                    namespace local {
+                        type function_ = string;
+                    }
+                    type local = {
+                        readonly 'function': local.function_;
+                    };
+                }
+                type scope = readonly ['external', scope.external] | readonly ['local', scope.local];
+                type context = Expression_;
+                namespace arguments_ {
+                    type omit = null;
+                    type pass_through = null;
+                    type initialize = Expression_;
+                }
+                type arguments_ = readonly ['omit', arguments_.omit] | readonly ['pass through', arguments_.pass_through] | readonly ['initialize', arguments_.initialize];
+            }
+            type serialize = {
+                readonly 'scope': serialize.scope;
+                readonly 'context': serialize.context;
+                readonly 'arguments': serialize.arguments_;
+            };
+        }
+        type text = readonly ['literal', text.literal] | readonly ['serialize', text.serialize];
+    }
+    type initialize = readonly ['boolean', initialize.boolean_] | readonly ['dictionary', initialize.dictionary] | readonly ['group', initialize.group] | readonly ['list', initialize.list] | readonly ['nothing', initialize.nothing] | readonly ['number', initialize.number_] | readonly ['optional', initialize.optional] | readonly ['reference', initialize.reference] | readonly ['state', initialize.state] | readonly ['text', initialize.text];
+    type select = Select_Value_;
+}
+type Expression_ = readonly ['change context', Expression_.change_context] | readonly ['convert', Expression_.convert] | readonly ['implement me', Expression_.implement_me] | readonly ['initialize', Expression_.initialize] | readonly ['select', Expression_.select];
+declare namespace Schema_Reference_ {
+    type sibling = string;
+    namespace external {
+        type package_ = string;
+        type module_ = string;
+        type schema = string;
+    }
+    type external = {
+        readonly 'package': external.package_;
+        readonly 'module': external.module_;
+        readonly 'schema': external.schema;
     };
 }
-export type Expression = [
-    'implement me',
-    {
-        'remark': string;
+type Schema_Reference_ = readonly ['sibling', Schema_Reference_.sibling] | readonly ['external', Schema_Reference_.external];
+declare namespace Type_Reference_ {
+    type type_ = string;
+}
+type Type_Reference_ = {
+    readonly 'type': Type_Reference_.type_;
+};
+declare namespace Root_ {
+    type development_mode = boolean;
+    type target_schema = Schema_Reference_;
+    namespace parameters_schema {
+        type O = Schema_Reference_;
     }
-];
+    type parameters_schema = p_.Optional_Value<parameters_schema.O>;
+    namespace dependencies {
+        namespace serializers {
+            namespace D {
+                type this_schema = null;
+                namespace cousin {
+                    type schema = string;
+                }
+                type cousin = {
+                    readonly 'schema': cousin.schema;
+                };
+                namespace external {
+                    type package_ = string;
+                    type module_ = string;
+                    type schema = string;
+                }
+                type external = {
+                    readonly 'package': external.package_;
+                    readonly 'module': external.module_;
+                    readonly 'schema': external.schema;
+                };
+            }
+            type D = readonly ['this schema', D.this_schema] | readonly ['cousin', D.cousin] | readonly ['external', D.external];
+        }
+        type serializers = p_.Dictionary<serializers.D>;
+        namespace transformers {
+            namespace D {
+                namespace sibling {
+                    type transformer = string;
+                }
+                type sibling = {
+                    readonly 'transformer': sibling.transformer;
+                };
+                namespace cousin {
+                    type schema = string;
+                    type transformer = string;
+                }
+                type cousin = {
+                    readonly 'schema': cousin.schema;
+                    readonly 'transformer': cousin.transformer;
+                };
+                namespace external {
+                    type package_ = string;
+                    type module_ = string;
+                    type schema = string;
+                    type transformer = string;
+                }
+                type external = {
+                    readonly 'package': external.package_;
+                    readonly 'module': external.module_;
+                    readonly 'schema': external.schema;
+                    readonly 'transformer': external.transformer;
+                };
+            }
+            type D = readonly ['sibling', D.sibling] | readonly ['cousin', D.cousin] | readonly ['external', D.external];
+        }
+        type transformers = p_.Dictionary<transformers.D>;
+    }
+    type dependencies = {
+        readonly 'serializers': dependencies.serializers;
+        readonly 'transformers': dependencies.transformers;
+    };
+    namespace declarations {
+        namespace D {
+            type target = Value_Reference_;
+            namespace parameters {
+                type O = Type_Reference_;
+            }
+            type parameters = p_.Optional_Value<parameters.O>;
+        }
+        type D = {
+            readonly 'target': D.target;
+            readonly 'parameters': D.parameters;
+        };
+    }
+    type declarations = p_.Dictionary<declarations.D>;
+    namespace implementations {
+        namespace D {
+            type temp_has_parameters = boolean;
+            type expression = Expression_;
+        }
+        type D = {
+            readonly 'temp has parameters': D.temp_has_parameters;
+            readonly 'expression': D.expression;
+        };
+    }
+    type implementations = p_.Dictionary<implementations.D>;
+}
+type Root_ = {
+    readonly 'development mode': Root_.development_mode;
+    readonly 'target schema': Root_.target_schema;
+    readonly 'parameters schema': Root_.parameters_schema;
+    readonly 'dependencies': Root_.dependencies;
+    readonly 'declarations': Root_.declarations;
+    readonly 'implementations': Root_.implementations;
+};
+export { type Value_Selection_Tail_ as Value_Selection_Tail, type Select_Value_ as Select_Value, type Value_Reference_ as Value_Reference, type Expression_ as Expression, type Schema_Reference_ as Schema_Reference, type Type_Reference_ as Type_Reference, type Root_ as Root, };

package/dist/modules/pareto_new/schemas/transformer/schema.js

@@ -1,5 +1,4 @@
 import * as p_ from 'pareto-core/schema';
-import * as i_value_reference from "../value_reference/schema.js";
-import * as i_type_reference from "../type_reference/schema.js";
-import * as i_schema_reference from "../schema_reference/schema.js";
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvcGFyZXRvX25ldy9zY2hlbWFzL3RyYW5zZm9ybWVyL3NjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBRXhDLE9BQU8sS0FBSyxpQkFBaUIsTUFBTSw4QkFBOEIsQ0FBQTtBQUNqRSxPQUFPLEtBQUssZ0JBQWdCLE1BQU0sNkJBQTZCLENBQUE7QUFDL0QsT0FBTyxLQUFLLGtCQUFrQixNQUFNLCtCQUErQixDQUFBIn0=
+// exported root types
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvcGFyZXRvX25ldy9zY2hlbWFzL3RyYW5zZm9ybWVyL3NjaGVtYS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLG9CQUFvQixDQUFBO0FBdXNCeEMsc0JBQXNCO0FBQ3RCLE9BQU8sRUFRTixDQUFBIn0=

package/dist/modules/pareto_new/schemas/transformer/shorthands/target.d.ts

@@ -1,8 +1,80 @@
 import * as p_ from 'pareto-core-shorthands/unconstrained_target';
 import type * as s_out from "../schema.js";
-export declare const root: (development_mode: boolean, target_schema: s_out.Root.target_schema, parameters_schema: s_out.Root.parameters_schema, declarations: p_.Normal_Dictionary<s_out.Root.declarations_D>, dependencies: p_.Normal_Dictionary<s_out.Root.dependencies_D>, implementations: p_.Normal_Dictionary<s_out.Root.implementations_D>) => s_out.Root;
-export declare const declaration: (target_value: s_out.Root.declarations_D["target value"], parameter: s_out.Root.declarations_D["parameter"]) => s_out.Root.declarations_D;
-export declare const implementation: (expression: s_out.Expression) => s_out.Root.implementations_D;
+export * as schema_reference from "../../schema_reference/shorthands/target.js";
+export declare const root: (development_mode: boolean, target_schema: s_out.Root.target_schema, parameters_schema: s_out.Root.parameters_schema, dependencies_serializers: p_.Normal_Dictionary<s_out.Root.dependencies.serializers.D>, dependencies_transformers: p_.Normal_Dictionary<s_out.Root.dependencies.transformers.D>, declarations: p_.Normal_Dictionary<s_out.Root.declarations.D>, implementations: p_.Normal_Dictionary<s_out.Root.implementations.D>) => s_out.Root;
+export declare namespace dependency {
+    namespace serializer {
+        const cousin: (schema: string) => s_out.Root.dependencies.serializers.D;
+        const external: (pkg: string, module: string, schema: string) => s_out.Root.dependencies.serializers.D;
+        const this_schema: () => s_out.Root.dependencies.serializers.D;
+    }
+    namespace transformer {
+        const cousin: (schema: string, transformer: string) => s_out.Root.dependencies.transformers.D;
+        const external: (pkg: string, module: string, schema: string, transformer: string) => s_out.Root.dependencies.transformers.D;
+        const sibling: (transformer: string) => s_out.Root.dependencies.transformers.D;
+    }
+}
+export declare const declaration: (target: s_out.Root.declarations.D.target, parameters: s_out.Root.declarations.D.parameters) => s_out.Root.declarations.D;
+export declare const implementation: (temp_has_parameters: boolean, expression: s_out.Expression) => s_out.Root.implementations.D;
 export declare namespace expr {
+    const change_context: (select: s_out.Expression.change_context.select, callback: s_out.Expression.change_context.callback) => s_out.Expression;
+    namespace convert {
+        namespace component {
+            const transform: (select: s_out.Select_Value, scope: s_out.Expression.convert.type_.component.transform.scope, arguments_: null | "pass through" | s_out.Expression) => s_out.Expression;
+            namespace transform_ {
+                const external: (transformer: string, function_: string) => s_out.Expression.convert.type_.component.transform.scope;
+                const local: (function_: string) => s_out.Expression.convert.type_.component.transform.scope;
+            }
+        }
+        namespace dictionary {
+            const map: (select: s_out.Expression.convert.select, on_entry: s_out.Expression.convert.type_.dictionary.map.on_entry) => s_out.Expression;
+        }
+        namespace group {
+        }
+        namespace list {
+            const map: (select: s_out.Expression.convert.select, on_item: s_out.Expression.convert.type_.list.map.on_item) => s_out.Expression;
+        }
+        namespace optional {
+            const decide: (select: s_out.Expression.convert.select, temp_return_value: s_out.Expression.convert.type_.optional.decide.temp_return_type, on_set: s_out.Expression.convert.type_.optional.map.on_set, on_not_set: s_out.Expression.convert.type_.optional.map.on_set) => s_out.Expression;
+            const map: (select: s_out.Expression.convert.select, on_set: s_out.Expression.convert.type_.optional.map.on_set) => s_out.Expression;
+        }
+        namespace state {
+            const decide: (select: s_out.Expression.convert.select, temp_return_value: s_out.Expression.convert.type_.optional.decide.temp_return_type, options: s_out.Expression.convert.type_.state.decide.options) => s_out.Expression;
+        }
+    }
     const implement_me: (remark: string) => s_out.Expression;
+    namespace initialize {
+        const false_: () => s_out.Expression;
+        const true_: () => s_out.Expression;
+        const dictionary: (dict: s_out.Expression.initialize.dictionary) => s_out.Expression;
+        const group: (group: s_out.Expression.initialize.group) => s_out.Expression;
+        const list: (list: s_out.Expression.initialize.list) => s_out.Expression;
+        const nothing: () => s_out.Expression;
+        const not_set: () => s_out.Expression;
+        const set: (value: s_out.Expression) => s_out.Expression;
+        const state: (option: string, data: s_out.Expression) => s_out.Expression;
+        const serialize: (scope: s_out.Expression.initialize.text.serialize.scope, context: s_out.Expression, arguments_: null | "pass through" | s_out.Expression) => s_out.Expression;
+        namespace serialize_ {
+            const external: (serializer: string, function_: string) => s_out.Expression.initialize.text.serialize.scope;
+            const local: (function_: string) => s_out.Expression.initialize.text.serialize.scope;
+        }
+        const text_literal: (text: string) => s_out.Expression;
+        const reference: (reference: s_out.Expression.initialize.reference) => s_out.Expression;
+    }
+    const select: (value_selection: s_out.Select_Value) => s_out.Expression;
+}
+export declare namespace select {
+    const call: (scope: s_out.Select_Value.call.scope, context: s_out.Select_Value, arguments_: null | "pass through" | s_out.Expression, tail: s_out.Select_Value.call.tail) => s_out.Select_Value;
+    namespace call_ {
+        const external: (transformer: string, function_: string) => s_out.Select_Value.call.scope;
+        const local: (function_: string) => s_out.Select_Value.call.scope;
+    }
+    const context_value: (tail: s_out.Select_Value.context_value.tail) => s_out.Select_Value;
+}
+export declare namespace vr {
+    const dictionary: () => s_out.Value_Reference.subselection.L;
+    const group: (property: string) => s_out.Value_Reference.subselection.L;
+    const list: () => s_out.Value_Reference.subselection.L;
+    const optional: () => s_out.Value_Reference.subselection.L;
+    const state: (option: string) => s_out.Value_Reference.subselection.L;
 }