pareto 0.80.74 → 0.80.75

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

@@ -1,3 +1,13 @@
 import type * as s_out from "../schema.js";
+export * as refiner from "../../refiner/shorthands/target.js";
+export * as schema_reference from "../../schema_reference/shorthands/target.js";
+export * as schema from "../../schema/shorthands/target.js";
+export * as transformer from "../../transformer/shorthands/target.js";
+export * as serializer from "../../serializer/shorthands/target.js";
+export * as deserializer from "../../deserializer/shorthands/target.js";
+export * as command_implementation from "../../command_implementation/shorthands/target.js";
+export * as command_interface from "../../command_interface/shorthands/target.js";
+export * as query_implementation from "../../query_implementation/shorthands/target.js";
+export * as query_interface from "../../query_interface/shorthands/target.js";
 export declare const module: (submodules: s_out.Module["modules"], schema_packages: s_out.Module["schemas"], query_interfaces: s_out.Module["queries"]["interfaces"], query_implementations: s_out.Module["queries"]["implementations"], command_interfaces: s_out.Module["commands"]["interfaces"], command_implementations: s_out.Module["commands"]["implementations"]) => s_out.Module;
 export declare const schema_package: (schema: s_out.Schema_Package["schema"], transformers: s_out.Schema_Package["transformers"], serializers: s_out.Schema_Package["serializers"], refiners: s_out.Schema_Package["refiners"], deserializers: s_out.Schema_Package["deserializers"]) => s_out.Schema_Package;

package/dist/modules/pareto_new/schemas/module/shorthands/target.js

@@ -1,4 +1,14 @@
 import * as p_ from 'pareto-core-shorthands/unconstrained_target';
+export * as refiner from "../../refiner/shorthands/target.js";
+export * as schema_reference from "../../schema_reference/shorthands/target.js";
+export * as schema from "../../schema/shorthands/target.js";
+export * as transformer from "../../transformer/shorthands/target.js";
+export * as serializer from "../../serializer/shorthands/target.js";
+export * as deserializer from "../../deserializer/shorthands/target.js";
+export * as command_implementation from "../../command_implementation/shorthands/target.js";
+export * as command_interface from "../../command_interface/shorthands/target.js";
+export * as query_implementation from "../../query_implementation/shorthands/target.js";
+export * as query_interface from "../../query_interface/shorthands/target.js";
 export const module = (submodules, schema_packages, query_interfaces, query_implementations, command_interfaces, command_implementations) => ({
     'modules': submodules,
     'schemas': schema_packages,
@@ -18,4 +28,4 @@ export const schema_package = (schema, transformers, serializers, refiners, dese
     'refiners': refiners,
     'deserializers': deserializers,
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFyZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvcGFyZXRvX25ldy9zY2hlbWFzL21vZHVsZS9zaG9ydGhhbmRzL3RhcmdldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLDZDQUE2QyxDQUFBO0FBSWpFLE1BQU0sQ0FBQyxNQUFNLE1BQU0sR0FBRyxDQUNsQixVQUFtQyxFQUNuQyxlQUF3QyxFQUN4QyxnQkFBdUQsRUFDdkQscUJBQWlFLEVBQ2pFLGtCQUEwRCxFQUMxRCx1QkFBb0UsRUFDeEQsRUFBRSxDQUFDLENBQUM7SUFDaEIsU0FBUyxFQUFFLFVBQVU7SUFDckIsU0FBUyxFQUFFLGVBQWU7SUFDMUIsU0FBUyxFQUFFO1FBQ1AsaUJBQWlCLEVBQUUscUJBQXFCO1FBQ3hDLFlBQVksRUFBRSxnQkFBZ0I7S0FDakM7SUFDRCxVQUFVLEVBQUU7UUFDUixpQkFBaUIsRUFBRSx1QkFBdUI7UUFDMUMsWUFBWSxFQUFFLGtCQUFrQjtLQUNuQztDQUNKLENBQUMsQ0FBQTtBQUVGLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUMxQixNQUFzQyxFQUN0QyxZQUFrRCxFQUNsRCxXQUFnRCxFQUNoRCxRQUEwQyxFQUMxQyxhQUFvRCxFQUNoQyxFQUFFLENBQUMsQ0FBQztJQUN4QixRQUFRLEVBQUUsTUFBTTtJQUNoQixjQUFjLEVBQUUsWUFBWTtJQUM1QixhQUFhLEVBQUUsV0FBVztJQUMxQixVQUFVLEVBQUUsUUFBUTtJQUNwQixlQUFlLEVBQUUsYUFBYTtDQUNqQyxDQUFDLENBQUEifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFyZ2V0LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvcGFyZXRvX25ldy9zY2hlbWFzL21vZHVsZS9zaG9ydGhhbmRzL3RhcmdldC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssRUFBRSxNQUFNLDZDQUE2QyxDQUFBO0FBSWpFLE9BQU8sS0FBSyxPQUFPLE1BQU0sb0NBQW9DLENBQUE7QUFDN0QsT0FBTyxLQUFLLGdCQUFnQixNQUFNLDZDQUE2QyxDQUFBO0FBQy9FLE9BQU8sS0FBSyxNQUFNLE1BQU0sbUNBQW1DLENBQUE7QUFDM0QsT0FBTyxLQUFLLFdBQVcsTUFBTSx3Q0FBd0MsQ0FBQTtBQUNyRSxPQUFPLEtBQUssVUFBVSxNQUFNLHVDQUF1QyxDQUFBO0FBQ25FLE9BQU8sS0FBSyxZQUFZLE1BQU0seUNBQXlDLENBQUE7QUFDdkUsT0FBTyxLQUFLLHNCQUFzQixNQUFNLG1EQUFtRCxDQUFBO0FBQzNGLE9BQU8sS0FBSyxpQkFBaUIsTUFBTSw4Q0FBOEMsQ0FBQTtBQUNqRixPQUFPLEtBQUssb0JBQW9CLE1BQU0saURBQWlELENBQUE7QUFDdkYsT0FBTyxLQUFLLGVBQWUsTUFBTSw0Q0FBNEMsQ0FBQTtBQUU3RSxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUcsQ0FDbEIsVUFBbUMsRUFDbkMsZUFBd0MsRUFDeEMsZ0JBQXVELEVBQ3ZELHFCQUFpRSxFQUNqRSxrQkFBMEQsRUFDMUQsdUJBQW9FLEVBQ3hELEVBQUUsQ0FBQyxDQUFDO0lBQ2hCLFNBQVMsRUFBRSxVQUFVO0lBQ3JCLFNBQVMsRUFBRSxlQUFlO0lBQzFCLFNBQVMsRUFBRTtRQUNQLGlCQUFpQixFQUFFLHFCQUFxQjtRQUN4QyxZQUFZLEVBQUUsZ0JBQWdCO0tBQ2pDO0lBQ0QsVUFBVSxFQUFFO1FBQ1IsaUJBQWlCLEVBQUUsdUJBQXVCO1FBQzFDLFlBQVksRUFBRSxrQkFBa0I7S0FDbkM7Q0FDSixDQUFDLENBQUE7QUFFRixNQUFNLENBQUMsTUFBTSxjQUFjLEdBQUcsQ0FDMUIsTUFBc0MsRUFDdEMsWUFBa0QsRUFDbEQsV0FBZ0QsRUFDaEQsUUFBMEMsRUFDMUMsYUFBb0QsRUFDaEMsRUFBRSxDQUFDLENBQUM7SUFDeEIsUUFBUSxFQUFFLE1BQU07SUFDaEIsY0FBYyxFQUFFLFlBQVk7SUFDNUIsYUFBYSxFQUFFLFdBQVc7SUFDMUIsVUFBVSxFQUFFLFFBQVE7SUFDcEIsZUFBZSxFQUFFLGFBQWE7Q0FDakMsQ0FBQyxDQUFBIn0=

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

@@ -1,47 +1,416 @@
 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;
-    'source schema': i_schema_reference.Schema_Reference;
-    'error schema': p_.Optional_Value<i_schema_reference.Schema_Reference>;
-    'parameters schema': p_.Optional_Value<i_schema_reference.Schema_Reference>;
-    'declarations': p_.Dictionary<Root.declarations_D>;
-    'dependencies': p_.Dictionary<Root.dependencies_D>;
-    'implementations': p_.Dictionary<Root.implementations_D>;
-};
-export declare namespace Root {
-    type declarations_D = {
-        'source': ['value', i_value_reference.Value_Reference] | ['iterator', i_value_reference.Value_Reference];
-        'error': p_.Optional_Value<i_type_reference.Type_Reference>;
-        'parameter': p_.Optional_Value<i_type_reference.Type_Reference>;
+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 refiner = string;
+                type function_ = string;
+            }
+            type external = {
+                readonly 'refiner': external.refiner;
+                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 error {
+            type omit = null;
+            type pass_through = null;
+            namespace handle {
+                type expression = Expression_;
+            }
+            type handle = {
+                readonly 'expression': handle.expression;
+            };
+        }
+        type error = readonly ['omit', error.omit] | readonly ['pass through', error.pass_through] | readonly ['handle', error.handle];
+        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 tail = Value_Selection_Tail_;
+    }
+    type call = {
+        readonly 'scope': call.scope;
+        readonly 'context': call.context;
+        readonly 'error': call.error;
+        readonly 'arguments': call.arguments_;
+        readonly 'tail': call.tail;
     };
-    type dependencies_D = {};
-    type implementations_D = {
-        'expression': Expression;
+    namespace context_value {
+        type tail = Value_Selection_Tail_;
+    }
+    type context_value = {
+        readonly 'tail': context_value.tail;
     };
 }
-export type Expression = ['from', Expression.from] | [
-    'implement me',
-    {
-        'remark': string;
-    }
-];
-export declare namespace Expression {
-    type from = {
-        'selection': Value_Selection;
-        'type': ['dictionary map', null];
+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;
+};
+declare namespace Expression_ {
+    type abort = 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 refiner = string;
+                            type function_ = string;
+                        }
+                        type external = {
+                            readonly 'refiner': external.refiner;
+                            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 error {
+                        type omit = null;
+                        type pass_through = null;
+                        type handle = Expression_;
+                    }
+                    type error = readonly ['omit', error.omit] | readonly ['pass through', error.pass_through] | readonly ['handle', error.handle];
+                    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 transform = {
+                    readonly 'scope': transform.scope;
+                    readonly 'error': transform.error;
+                    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];
+            namespace text {
+                namespace decide {
+                    namespace temp_return_type {
+                        type O = Value_Reference_;
+                    }
+                    type temp_return_type = p_.Optional_Value<temp_return_type.O>;
+                    namespace matches {
+                        type D = Expression_;
+                    }
+                    type matches = p_.Dictionary<matches.D>;
+                    type no_match = Expression_;
+                }
+                type decide = {
+                    readonly 'temp return type': decide.temp_return_type;
+                    readonly 'matches': decide.matches;
+                    readonly 'no match': decide.no_match;
+                };
+            }
+            type text = readonly ['decide', text.decide];
+        }
+        type type_ = readonly ['component', type_.component] | readonly ['dictionary', type_.dictionary] | readonly ['list', type_.list] | readonly ['optional', type_.optional] | readonly ['state', type_.state] | readonly ['text', type_.text];
+    }
+    type convert = {
+        readonly 'select': convert.select;
+        readonly 'type': convert.type_;
+    };
+    namespace implement_me {
+        type remark = string;
+    }
+    type implement_me = {
+        readonly 'remark': implement_me.remark;
     };
-    namespace from {
+    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;
+        };
+        type text = string;
+    }
+    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 ['abort', Expression_.abort] | 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;
+    };
+}
+type Schema_Reference_ = readonly ['sibling', Schema_Reference_.sibling] | readonly ['external', Schema_Reference_.external];
+declare namespace Type_Reference_ {
+    type type_ = string;
 }
-export type Value_Selection = {
-    'start': ['context value', null];
-    'tail': p_.List<Value_Selection.tail.L>;
+type Type_Reference_ = {
+    readonly 'type': Type_Reference_.type_;
 };
-export declare namespace Value_Selection {
-    namespace tail {
-        type L = string;
+declare namespace Root_ {
+    type development_mode = boolean;
+    type source_schema = Schema_Reference_;
+    namespace error_schema {
+        type O = Schema_Reference_;
+    }
+    type error_schema = p_.Optional_Value<error_schema.O>;
+    namespace parameters_schema {
+        type O = Schema_Reference_;
     }
+    type parameters_schema = p_.Optional_Value<parameters_schema.O>;
+    namespace dependencies {
+        namespace deserializers {
+            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 deserializers = p_.Dictionary<deserializers.D>;
+        namespace refiners {
+            namespace D {
+                namespace sibling {
+                    type refiner = string;
+                }
+                type sibling = {
+                    readonly 'refiner': sibling.refiner;
+                };
+                namespace cousin {
+                    type schema = string;
+                    type refiner = string;
+                }
+                type cousin = {
+                    readonly 'schema': cousin.schema;
+                    readonly 'refiner': cousin.refiner;
+                };
+                namespace external {
+                    type package_ = string;
+                    type module_ = string;
+                    type schema = string;
+                    type refiner = string;
+                }
+                type external = {
+                    readonly 'package': external.package_;
+                    readonly 'module': external.module_;
+                    readonly 'schema': external.schema;
+                    readonly 'refiner': external.refiner;
+                };
+            }
+            type D = readonly ['sibling', D.sibling] | readonly ['cousin', D.cousin] | readonly ['external', D.external];
+        }
+        type refiners = p_.Dictionary<refiners.D>;
+    }
+    type dependencies = {
+        readonly 'deserializers': dependencies.deserializers;
+        readonly 'refiners': dependencies.refiners;
+    };
+    namespace declarations {
+        namespace D {
+            namespace source {
+                type value = Value_Reference_;
+                type iterator = Value_Reference_;
+            }
+            type source = readonly ['value', source.value] | readonly ['iterator', source.iterator];
+            namespace error {
+                type O = Type_Reference_;
+            }
+            type error = p_.Optional_Value<error.O>;
+            namespace parameters {
+                type O = Type_Reference_;
+            }
+            type parameters = p_.Optional_Value<parameters.O>;
+        }
+        type D = {
+            readonly 'source': D.source;
+            readonly 'error': D.error;
+            readonly 'parameters': D.parameters;
+        };
+    }
+    type declarations = p_.Dictionary<declarations.D>;
+    namespace implementations {
+        namespace D {
+            type temp_has_error = boolean;
+            type temp_has_parameters = boolean;
+            type expression = Expression_;
+        }
+        type D = {
+            readonly 'temp has error': D.temp_has_error;
+            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 'source schema': Root_.source_schema;
+    readonly 'error schema': Root_.error_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/refiner/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvcGFyZXRvX25ldy9zY2hlbWFzL3JlZmluZXIvc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUFFeEMsT0FBTyxLQUFLLGlCQUFpQixNQUFNLDhCQUE4QixDQUFBO0FBQ2pFLE9BQU8sS0FBSyxnQkFBZ0IsTUFBTSw2QkFBNkIsQ0FBQTtBQUMvRCxPQUFPLEtBQUssa0JBQWtCLE1BQU0sK0JBQStCLENBQUEifQ==
+// exported root types
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2NoZW1hLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vc3JjL21vZHVsZXMvcGFyZXRvX25ldy9zY2hlbWFzL3JlZmluZXIvc2NoZW1hLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxFQUFFLE1BQU0sb0JBQW9CLENBQUE7QUF1dkJ4QyxzQkFBc0I7QUFDdEIsT0FBTyxFQVFOLENBQUEifQ==

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

@@ -1,12 +1,84 @@
 import * as p_ from 'pareto-core-shorthands/unconstrained_target';
 import type * as s_out from "../schema.js";
-import type * as s_vr from "../../value_reference/schema.js";
-export declare const root: (development_mode: boolean, source_schema: s_out.Root["source schema"], error_schema: s_out.Root["error 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 * as schema_reference from "../../schema_reference/shorthands/target.js";
+export declare const root: (development_mode: boolean, source_schema: s_out.Root.source_schema, error_schema: s_out.Root.error_schema, parameters_schema: s_out.Root.parameters_schema, dependencies_dererializers: p_.Normal_Dictionary<s_out.Root.dependencies.deserializers.D>, dependencies_refiners: p_.Normal_Dictionary<s_out.Root.dependencies.refiners.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 deserializer {
+        const cousin: (schema: string) => s_out.Root.dependencies.deserializers.D;
+        const external: (pkg: string, module: string, schema: string) => s_out.Root.dependencies.deserializers.D;
+        const this_schema: () => s_out.Root.dependencies.deserializers.D;
+    }
+    namespace refiner {
+        const cousin: (schema: string, refiner: string) => s_out.Root.dependencies.refiners.D;
+        const external: (pkg: string, module: string, schema: string, refiner: string) => s_out.Root.dependencies.refiners.D;
+        const sibling: (refiner: string) => s_out.Root.dependencies.refiners.D;
+    }
+}
 export declare namespace declaration {
-    const production: (source: s_vr.Value_Reference, error: s_out.Root.declarations_D["error"], parameter: s_out.Root.declarations_D["parameter"]) => s_out.Root.declarations_D;
-    const refiner: (source: s_vr.Value_Reference, error: s_out.Root.declarations_D["error"], parameter: s_out.Root.declarations_D["parameter"]) => s_out.Root.declarations_D;
+    const production: (source: s_out.Root.declarations.D.source.iterator, error: s_out.Root.declarations.D.error, parameters: s_out.Root.declarations.D.parameters) => s_out.Root.declarations.D;
+    const refiner: (source: s_out.Root.declarations.D.source.value, error: s_out.Root.declarations.D.error, parameters: s_out.Root.declarations.D.parameters) => s_out.Root.declarations.D;
 }
-export declare const implementation: (expression: s_out.Expression) => s_out.Root.implementations_D;
+export declare const implementation: (temp_has_error: boolean, temp_has_parameters: boolean, expression: s_out.Expression) => s_out.Root.implementations.D;
 export declare namespace expr {
+    const abort: (expression: s_out.Expression) => s_out.Expression;
+    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.Expression.convert.select, scope: s_out.Expression.convert.type_.component.transform.scope, error: null | "pass through" | s_out.Expression, arguments_: null | "pass through" | s_out.Expression) => s_out.Expression;
+            namespace transform_ {
+                const external: (refiner: 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;
+        }
+        namespace text {
+            const decide: (select: s_out.Expression.convert.select, temp_return_value: s_out.Expression.convert.type_.optional.decide.temp_return_type, matches: s_out.Expression.convert.type_.text.decide.matches, no_match: s_out.Expression.convert.type_.text.decide.no_match) => 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 natural: (value: number) => s_out.Expression;
+        const integer: (value: number) => 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 text: (text: s_out.Expression.initialize.text) => 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, error: null | "pass through" | s_out.Expression, arguments_: null | "pass through" | s_out.Expression, tail: s_out.Select_Value.call.tail) => s_out.Select_Value;
+    namespace call_ {
+        const external: (refiner: 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;
 }