exupery-core-async 0.3.8 → 0.3.10

package/dist/algorithms/procedure/{initialize_unguaranteed_procedure.d.ts → initialize_procedure.d.ts}

@@ -13,5 +13,5 @@ type Executer<E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_unguaranteed_procedure<E>(executer: Executer<E>): _et.Unguaranteed_Procedure_Promise<E>;
+export declare function __create_procedure<E>(executer: Executer<E>): _et.Procedure_Promise<E>;
 export {};

package/dist/algorithms/procedure/{initialize_unguaranteed_procedure.js → initialize_procedure.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__create_unguaranteed_procedure = __create_unguaranteed_procedure;
-class Unguaranteed_Procedure_Promise_Class {
+exports.__create_procedure = __create_procedure;
+class Procedure_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
@@ -9,7 +9,7 @@ class Unguaranteed_Procedure_Promise_Class {
         this.executer.execute(on_success, on_exception);
     }
     map_error(handle_error) {
-        return new Unguaranteed_Procedure_Promise_Class({
+        return new Procedure_Promise_Class({
             'execute': (on_success, on_exception) => {
                 this.executer.execute(on_success, (error) => {
                     on_exception(handle_error(error));
@@ -23,6 +23,6 @@ class Unguaranteed_Procedure_Promise_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __create_unguaranteed_procedure(executer) {
-    return new Unguaranteed_Procedure_Promise_Class(executer);
+function __create_procedure(executer) {
+    return new Procedure_Promise_Class(executer);
 }

package/dist/algorithms/query/{create_unguaranteed_query.d.ts → create_query.d.ts}

@@ -13,5 +13,5 @@ type Executer<T, E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_unguaranteed_query<T, E>(executer: Executer<T, E>): _et.Unguaranteed_Query_Promise<T, E>;
+export declare function __create_query<T, E>(executer: Executer<T, E>): _et.Query_Promise<T, E>;
 export {};

package/dist/algorithms/query/{create_unguaranteed_query.js → create_query.js}

@@ -1,13 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.__create_unguaranteed_query = __create_unguaranteed_query;
-const create_guaranteed_query_1 = require("./create_guaranteed_query");
-class Unguaranteed_Query_Result_Promise_Class {
+exports.__create_query = __create_query;
+class Query_Result_Promise_Class {
     constructor(executer) {
         this.executer = executer;
     }
     map_(handle_value) {
-        return new Unguaranteed_Query_Result_Promise_Class({
+        return new Query_Result_Promise_Class({
             'execute': (on_value, on_exception) => {
                 this.executer.execute(($) => {
                     on_value(handle_value($));
@@ -16,16 +15,7 @@ class Unguaranteed_Query_Result_Promise_Class {
         });
     }
     then(handle_value) {
-        return new Unguaranteed_Query_Result_Promise_Class({
-            'execute': (new_on_value, new_on_exception) => {
-                this.executer.execute(($) => {
-                    handle_value($).__start(new_on_value);
-                }, new_on_exception);
-            }
-        });
-    }
-    then_unguaranteed(handle_value) {
-        return new Unguaranteed_Query_Result_Promise_Class({
+        return new Query_Result_Promise_Class({
             'execute': (new_on_value, new_on_exception) => {
                 this.executer.execute(($) => {
                     handle_value($).__start(new_on_value, new_on_exception);
@@ -34,7 +24,7 @@ class Unguaranteed_Query_Result_Promise_Class {
         });
     }
     map_exception_(handle_exception) {
-        return new Unguaranteed_Query_Result_Promise_Class({
+        return new Query_Result_Promise_Class({
             'execute': (on_value, on_exception) => {
                 this.executer.execute(on_value, ($) => {
                     on_exception(handle_exception($));
@@ -42,15 +32,6 @@ class Unguaranteed_Query_Result_Promise_Class {
             }
         });
     }
-    catch_(handle_exception) {
-        return (0, create_guaranteed_query_1.__create_guaranteed_query)({
-            'execute': (on_value) => {
-                this.executer.execute(on_value, ($) => {
-                    handle_exception($).__start(on_value);
-                });
-            }
-        });
-    }
     __start(on_value, on_exception) {
         this.executer.execute(on_value, on_exception);
     }
@@ -60,6 +41,6 @@ class Unguaranteed_Query_Result_Promise_Class {
  * @param executer the function that produces the eventual value
  * @returns
  */
-function __create_unguaranteed_query(executer) {
-    return new Unguaranteed_Query_Result_Promise_Class(executer);
+function __create_query(executer) {
+    return new Query_Result_Promise_Class(executer);
 }

package/dist/index.d.ts

@@ -1,11 +1,7 @@
 import * as _et from "exupery-core-types";
-export * from "./types/Basic_Unguaranteed_Query";
-export * from "./types/Basic_Guaranteed_Query";
-export * from "./algorithms/query/merge_2_guaranteed_queries";
-export * from "./algorithms/query/create_guaranteed_query";
-export * from "./algorithms/query/create_unguaranteed_query";
-export * from "./algorithms/procedure/initialize_guaranteed_procedure";
-export * from "./algorithms/procedure/initialize_unguaranteed_procedure";
+export * from "./types/Basic_Query";
+export * from "./algorithms/query/create_query";
+export * from "./algorithms/procedure/initialize_procedure";
 export * from "./shorthands";
 export * from "./procedure/assert_async";
 export * from "./procedure/assert_sync";
@@ -15,15 +11,10 @@ export * from "./procedure/conditional_sync";
 export * from "./procedure/sequence";
 export * from "./procedure/three_steps";
 export * from "./procedure/two_steps";
-export * from "./procedure/unguaranteed_procedure_dictionary";
+export * from "./procedure/procedure_dictionary";
 export * from "./query/transform_query";
-export * from "./query/unguaranteed_query_dictionary";
+export * from "./query/query_dictionary";
 export declare const query: {
-    guaranteed: {
-        'create result': <T>($: T) => _et.Guaranteed_Query_Promise<T>;
-    };
-    unguaranteed: {
-        'create result': <T, E>($: T) => _et.Unguaranteed_Query_Promise<T, E>;
-        'raise exception': <T, E>($: E) => _et.Unguaranteed_Query_Promise<T, E>;
-    };
+    'create result': <T, E>($: T) => _et.Query_Promise<T, E>;
+    'raise exception': <T, E>($: E) => _et.Query_Promise<T, E>;
 };

package/dist/index.js

@@ -16,14 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.query = void 0;
 //types
-__exportStar(require("./types/Basic_Unguaranteed_Query"), exports);
-__exportStar(require("./types/Basic_Guaranteed_Query"), exports);
+__exportStar(require("./types/Basic_Query"), exports);
 //functions
-__exportStar(require("./algorithms/query/merge_2_guaranteed_queries"), exports);
-__exportStar(require("./algorithms/query/create_guaranteed_query"), exports);
-__exportStar(require("./algorithms/query/create_unguaranteed_query"), exports);
-__exportStar(require("./algorithms/procedure/initialize_guaranteed_procedure"), exports);
-__exportStar(require("./algorithms/procedure/initialize_unguaranteed_procedure"), exports);
+__exportStar(require("./algorithms/query/create_query"), exports);
+__exportStar(require("./algorithms/procedure/initialize_procedure"), exports);
 __exportStar(require("./shorthands"), exports);
 // procedure exports
 __exportStar(require("./procedure/assert_async"), exports);
@@ -34,36 +30,24 @@ __exportStar(require("./procedure/conditional_sync"), exports);
 __exportStar(require("./procedure/sequence"), exports);
 __exportStar(require("./procedure/three_steps"), exports);
 __exportStar(require("./procedure/two_steps"), exports);
-__exportStar(require("./procedure/unguaranteed_procedure_dictionary"), exports);
+__exportStar(require("./procedure/procedure_dictionary"), exports);
 // query exports
 __exportStar(require("./query/transform_query"), exports);
-__exportStar(require("./query/unguaranteed_query_dictionary"), exports);
-const create_guaranteed_query_1 = require("./algorithms/query/create_guaranteed_query");
-const create_unguaranteed_query_1 = require("./algorithms/query/create_unguaranteed_query");
+__exportStar(require("./query/query_dictionary"), exports);
+const create_query_1 = require("./algorithms/query/create_query");
 exports.query = {
-    'guaranteed': {
-        'create result': ($) => {
-            return (0, create_guaranteed_query_1.__create_guaranteed_query)({
-                'execute': (on_value) => {
-                    on_value($);
-                }
-            });
-        }
-    },
-    'unguaranteed': {
-        'create result': ($) => {
-            return (0, create_unguaranteed_query_1.__create_unguaranteed_query)({
-                'execute': (on_value) => {
-                    on_value($);
-                }
-            });
-        },
-        'raise exception': ($) => {
-            return (0, create_unguaranteed_query_1.__create_unguaranteed_query)({
-                'execute': (on_value, on_exception) => {
-                    on_exception($);
-                }
-            });
-        }
+    'create result': ($) => {
+        return (0, create_query_1.__create_query)({
+            'execute': (on_value) => {
+                on_value($);
+            }
+        });
     },
+    'raise exception': ($) => {
+        return (0, create_query_1.__create_query)({
+            'execute': (on_value, on_exception) => {
+                on_exception($);
+            }
+        });
+    }
 };

package/dist/procedure/assert_async.d.ts

@@ -1,3 +1,3 @@
 import * as _et from 'exupery-core-types';
 export type Assert_Async_Error<Assertion_Error, Procedure_Error> = ['assertion error', Assertion_Error] | ['assertion failed', null] | ['procedure error', Procedure_Error];
-export declare const assert_async: <Assertion_Error, Procedure_Error>(assertion: _et.Unguaranteed_Query_Promise<boolean, Assertion_Error>, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Assert_Async_Error<Assertion_Error, Procedure_Error>>;
+export declare const assert_async: <Assertion_Error, Procedure_Error>(assertion: _et.Query_Promise<boolean, Assertion_Error>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Assert_Async_Error<Assertion_Error, Procedure_Error>>;

package/dist/procedure/assert_async.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assert_async = void 0;
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const assert_async = (assertion, procedure) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             assertion.__start(($) => {
                 if ($) {

package/dist/procedure/assert_sync.d.ts

@@ -1,3 +1,3 @@
 import * as _et from 'exupery-core-types';
 export type Assert_Sync_Error<Procedure_Error> = ['assertion failed', null] | ['procedure error', Procedure_Error];
-export declare const assert_sync: <Assertion_Error, Procedure_Error>(assertion: boolean, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Assert_Sync_Error<Procedure_Error>>;
+export declare const assert_sync: <Assertion_Error, Procedure_Error>(assertion: boolean, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Assert_Sync_Error<Procedure_Error>>;

package/dist/procedure/assert_sync.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assert_sync = void 0;
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const assert_sync = (assertion, procedure) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             if (!assertion) {
                 on_exception(['assertion failed', null]);

package/dist/procedure/conditional_async.d.ts

@@ -1,4 +1,4 @@
 import * as _et from 'exupery-core-types';
-import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
+import { Basic_Query_Promise } from '../types/Basic_Query';
 export type Conditional_Async_Error<Precondition_Error, Procedure_Error> = ['precondition', Precondition_Error] | ['procedure', Procedure_Error];
-export declare const conditional_async: <Precondition_Error, Procedure_Error>(precondition: Basic_Unguaranteed_Query_Promise<boolean, Precondition_Error>, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Conditional_Async_Error<Precondition_Error, Procedure_Error>>;
+export declare const conditional_async: <Precondition_Error, Procedure_Error>(precondition: Basic_Query_Promise<boolean, Precondition_Error>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Conditional_Async_Error<Precondition_Error, Procedure_Error>>;

package/dist/procedure/conditional_async.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.conditional_async = void 0;
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const conditional_async = (precondition, procedure) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             precondition.__start(($) => {
                 if ($) {

package/dist/procedure/conditional_multiple.d.ts

@@ -1,4 +1,4 @@
 import * as _et from 'exupery-core-types';
-import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
+import { Basic_Query_Promise } from '../types/Basic_Query';
 export type Conditional_Multiple_Error<Precondition_Error, Procedure_Error> = ['preconditions', _et.Dictionary<Precondition_Error>] | ['procedure', Procedure_Error];
-export declare const conditional_multiple: <Precondition_Error, Procedure_Error>(preconditions: _et.Dictionary<Basic_Unguaranteed_Query_Promise<boolean, Precondition_Error>>, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Conditional_Multiple_Error<Precondition_Error, Procedure_Error>>;
+export declare const conditional_multiple: <Precondition_Error, Procedure_Error>(preconditions: _et.Dictionary<Basic_Query_Promise<boolean, Precondition_Error>>, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Conditional_Multiple_Error<Precondition_Error, Procedure_Error>>;

package/dist/procedure/conditional_multiple.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.conditional_multiple = void 0;
-const unguaranteed_query_dictionary_1 = require("../query/unguaranteed_query_dictionary");
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const query_dictionary_1 = require("../query/query_dictionary");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const conditional_multiple = (preconditions, procedure) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
-            (0, unguaranteed_query_dictionary_1.unguaranteed_query_dictionary)(preconditions).__start(($) => {
+            (0, query_dictionary_1.query_dictionary)(preconditions).__start(($) => {
                 let has_errors = false;
                 $.map(($) => {
                     if (!$) {

package/dist/procedure/conditional_sync.d.ts

@@ -1,2 +1,2 @@
 import * as _et from 'exupery-core-types';
-export declare const conditional_sync: <Procedure_Error>(precondition: boolean, procedure: _et.Unguaranteed_Procedure_Promise<Procedure_Error>) => _et.Unguaranteed_Procedure_Promise<Procedure_Error>;
+export declare const conditional_sync: <Procedure_Error>(precondition: boolean, procedure: _et.Procedure_Promise<Procedure_Error>) => _et.Procedure_Promise<Procedure_Error>;

package/dist/procedure/conditional_sync.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.conditional_sync = void 0;
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const conditional_sync = (precondition, procedure) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             if (precondition) {
                 procedure.__start(on_success, on_exception);

package/dist/procedure/procedure_dictionary.d.ts

@@ -0,0 +1,2 @@
+import * as _et from 'exupery-core-types';
+export declare const procedure_dictionary: <Error>($: _et.Dictionary<_et.Procedure_Promise<Error>>) => _et.Procedure_Promise<_et.Dictionary<Error>>;

package/dist/procedure/{unguaranteed_procedure_dictionary.js → procedure_dictionary.js}

@@ -23,11 +23,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unguaranteed_procedure_dictionary = void 0;
+exports.procedure_dictionary = void 0;
 const _ei = __importStar(require("exupery-core-internals"));
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
-const unguaranteed_procedure_dictionary = ($) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
+const procedure_dictionary = ($) => {
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             let count_down = $.__get_number_of_entries();
             let has_errors = false;
@@ -55,4 +55,4 @@ const unguaranteed_procedure_dictionary = ($) => {
         }
     });
 };
-exports.unguaranteed_procedure_dictionary = unguaranteed_procedure_dictionary;
+exports.procedure_dictionary = procedure_dictionary;

package/dist/procedure/sequence.d.ts

@@ -3,4 +3,4 @@ export type Sequence_Error<Err> = {
     'error': Err;
     'step': string;
 };
-export declare const sequence: <Err>(steps: _et.Dictionary<_et.Unguaranteed_Procedure_Promise<Err>>) => _et.Unguaranteed_Procedure_Promise<Sequence_Error<Err>>;
+export declare const sequence: <Err>(steps: _et.Dictionary<_et.Procedure_Promise<Err>>) => _et.Procedure_Promise<Sequence_Error<Err>>;

package/dist/procedure/sequence.js

@@ -25,7 +25,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sequence = void 0;
 const _ei = __importStar(require("exupery-core-internals"));
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const op_dictionary_to_list_based_on_insertion_order = (dict) => {
     const temp = [];
     dict.map(($, key) => {
@@ -34,7 +34,7 @@ const op_dictionary_to_list_based_on_insertion_order = (dict) => {
     return _ei.array_literal(temp);
 };
 const sequence = (steps) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             const as_list = op_dictionary_to_list_based_on_insertion_order(steps);
             let current = 0;

package/dist/procedure/three_steps.d.ts

@@ -1,3 +1,3 @@
 import * as _et from 'exupery-core-types';
 export type Three_Steps_Error<Step_1_Error, Step_2_Error, Step_3_Error> = ['step1', Step_1_Error] | ['step2', Step_2_Error] | ['step3', Step_3_Error];
-export declare const three_steps: <Step_1_Error, Step_2_Error, Step_3_Error>(step_1: _et.Unguaranteed_Procedure_Promise<Step_1_Error>, step_2: _et.Unguaranteed_Procedure_Promise<Step_2_Error>, step_3: _et.Unguaranteed_Procedure_Promise<Step_3_Error>) => _et.Unguaranteed_Procedure_Promise<Three_Steps_Error<Step_1_Error, Step_2_Error, Step_3_Error>>;
+export declare const three_steps: <Step_1_Error, Step_2_Error, Step_3_Error>(step_1: _et.Procedure_Promise<Step_1_Error>, step_2: _et.Procedure_Promise<Step_2_Error>, step_3: _et.Procedure_Promise<Step_3_Error>) => _et.Procedure_Promise<Three_Steps_Error<Step_1_Error, Step_2_Error, Step_3_Error>>;

package/dist/procedure/three_steps.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.three_steps = void 0;
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const three_steps = (step_1, step_2, step_3) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             step_1.__start(() => {
                 step_2.__start(() => {

package/dist/procedure/two_steps.d.ts

@@ -1,3 +1,3 @@
 import * as _et from 'exupery-core-types';
 export type Two_Steps_Error<Step_1_Error, Step_2_Error> = ['step1', Step_1_Error] | ['step2', Step_2_Error];
-export declare const two_steps: <Step_1_Error, Step_2_Error>(step_1: _et.Unguaranteed_Procedure_Promise<Step_1_Error>, step_2: _et.Unguaranteed_Procedure_Promise<Step_2_Error>) => _et.Unguaranteed_Procedure_Promise<Two_Steps_Error<Step_1_Error, Step_2_Error>>;
+export declare const two_steps: <Step_1_Error, Step_2_Error>(step_1: _et.Procedure_Promise<Step_1_Error>, step_2: _et.Procedure_Promise<Step_2_Error>) => _et.Procedure_Promise<Two_Steps_Error<Step_1_Error, Step_2_Error>>;

package/dist/procedure/two_steps.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.two_steps = void 0;
-const initialize_unguaranteed_procedure_1 = require("../algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("../algorithms/procedure/initialize_procedure");
 const two_steps = (step_1, step_2) => {
-    return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    return (0, initialize_procedure_1.__create_procedure)({
         'execute': (on_success, on_exception) => {
             step_1.__start(() => {
                 step_2.__start(on_success, (error) => {

package/dist/query/query_dictionary.d.ts

@@ -0,0 +1,3 @@
+import * as _et from 'exupery-core-types';
+import { Basic_Query_Promise } from '../types/Basic_Query';
+export declare const query_dictionary: <Result, Error>($: _et.Dictionary<Basic_Query_Promise<Result, Error>>) => _et.Query_Promise<_et.Dictionary<Result>, _et.Dictionary<Error>>;

package/dist/query/{unguaranteed_query_dictionary.js → query_dictionary.js}

@@ -23,11 +23,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.unguaranteed_query_dictionary = void 0;
+exports.query_dictionary = void 0;
 const _ei = __importStar(require("exupery-core-internals"));
-const create_unguaranteed_query_1 = require("../algorithms/query/create_unguaranteed_query");
-const unguaranteed_query_dictionary = ($) => {
-    return (0, create_unguaranteed_query_1.__create_unguaranteed_query)({
+const create_query_1 = require("../algorithms/query/create_query");
+const query_dictionary = ($) => {
+    return (0, create_query_1.__create_query)({
         'execute': (on_success, on_exception) => {
             let count_down = $.__get_number_of_entries();
             let has_errors = false;
@@ -57,4 +57,4 @@ const unguaranteed_query_dictionary = ($) => {
         }
     });
 };
-exports.unguaranteed_query_dictionary = unguaranteed_query_dictionary;
+exports.query_dictionary = query_dictionary;

package/dist/query/transform_query.d.ts

@@ -1,3 +1,3 @@
 import * as _et from 'exupery-core-types';
-import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
-export declare const transform_query: <In, Out, Error>(query: Basic_Unguaranteed_Query_Promise<In, Error>, transform: ($: In) => Out) => _et.Unguaranteed_Query_Promise<Out, Error>;
+import { Basic_Query_Promise } from '../types/Basic_Query';
+export declare const transform_query: <In, Out, Error>(query: Basic_Query_Promise<In, Error>, transform: ($: In) => Out) => _et.Query_Promise<Out, Error>;

package/dist/query/transform_query.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.transform_query = void 0;
-const create_unguaranteed_query_1 = require("../algorithms/query/create_unguaranteed_query");
+const create_query_1 = require("../algorithms/query/create_query");
 const transform_query = (query, transform) => {
-    return (0, create_unguaranteed_query_1.__create_unguaranteed_query)({
+    return (0, create_query_1.__create_query)({
         'execute': (on_success, on_exception) => {
             query.__start(($) => {
                 on_success(transform($));

package/dist/shorthands.d.ts

@@ -1,95 +1,50 @@
 import * as _et from 'exupery-core-types';
-import { Basic_Unguaranteed_Query_Promise } from "./types/Basic_Unguaranteed_Query";
-import { Basic_Guaranteed_Query_Promise } from "./types/Basic_Guaranteed_Query";
+import { Basic_Query_Promise } from "./types/Basic_Query";
 import { Error_Handler } from "./types/Error_Handler";
-/**
- *
- * @param action gpi
- * @param error_transform gt
- */
-export declare const eh: <Parameters, Error, Resources>(action: _et.Guaranteed_Procedure<Parameters, Resources>, error_transform: _et.Transformer_Without_Parameters<Error, Parameters>, resources: Resources) => Error_Handler<Error>;
-export declare namespace gp {
-    /**
-     *
-     * @param action gpi
-     * @param query g.q
-     * @returns
-     */
-    const action: <Parameters, Resources>(action: _et.Guaranteed_Procedure<Parameters, Resources>, query: Basic_Guaranteed_Query_Promise<Parameters>, $r: Resources) => _et.Guaranteed_Procedure_Promise;
-}
-export declare namespace gq {
-    /**
-     *
-     * @param query_result qr
-     * @returns
-     */
-    const fixed: <Query_Result>(query_result: Query_Result) => Basic_Guaranteed_Query_Promise<Query_Result>;
-    /**
-     *
-     * @param the_query gqi
-     * @param parameters g.q
-     * @param result_transformation gt
-     * @returns
-     */
-    const g: <Result_After_Transformation, Parameters, Query_Result, Resources>(the_query: _et.Guaranteed_Query<Parameters, Query_Result, Resources>, parameters: Basic_Guaranteed_Query_Promise<Parameters>, result_transformation: _et.Transformer_Without_Parameters<Query_Result, Result_After_Transformation>, resources: Resources) => Basic_Guaranteed_Query_Promise<Result_After_Transformation>;
-}
-export declare namespace gt {
-    /**
-     *
-     * @param the_transformation gt
-     * @returns
-     */
-    const g: <In, Out>(the_transformation: _et.Transformer_Without_Parameters<In, Out>) => _et.Transformer_Without_Parameters<In, Out>;
-}
-export declare namespace up {
+export declare namespace p {
     /**
      *
      * @param action upi
      * @param query u.q
      */
-    const action: <Error, Parameters, Resources>(action: _et.Unguaranteed_Procedure<Parameters, Error, Resources>, query: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources) => _et.Unguaranteed_Procedure_Promise<Error>;
+    const action: <Error, Parameters, Resources>(action: _et.Procedure<Parameters, Error, Resources>, query: Basic_Query_Promise<Parameters, Error>, resources: Resources) => _et.Procedure_Promise<Error>;
     /**
      *
      * @param steps up[]
      * @returns
      */
-    const sequence: <Error>(steps: _et.Unguaranteed_Procedure_Promise<Error>[]) => _et.Unguaranteed_Procedure_Promise<Error>;
+    const sequence: <Error>(steps: _et.Procedure_Promise<Error>[]) => _et.Procedure_Promise<Error>;
     /**
      *
      * @param the_array up[]
      * @param aggregate_exceptions gt
      * @returns
      */
-    const array: <Error, Element_Error>(the_array: _et.Array<_et.Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _et.Transformer_Without_Parameters<_et.Array<Element_Error>, Error>) => _et.Unguaranteed_Procedure_Promise<Error>;
+    const array: <Error, Element_Error>(the_array: _et.Array<_et.Procedure_Promise<Element_Error>>, aggregate_exceptions: _et.Transformer_Without_Parameters<_et.Array<Element_Error>, Error>) => _et.Procedure_Promise<Error>;
     /**
      *
      * @param the_dictionary dict<up>
      * @param aggregate_exceptions gt
      * @returns
      */
-    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<_et.Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _et.Transformer_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => _et.Unguaranteed_Procedure_Promise<Error>;
+    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<_et.Procedure_Promise<Element_Error>>, aggregate_exceptions: _et.Transformer_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => _et.Procedure_Promise<Error>;
 }
-export declare namespace upi {
-    /**
-     *
-     * @param action gpi
-     */
-    const g: <Parameters, Error, Resources>(action: _et.Guaranteed_Procedure<Parameters, Resources>, $r: Resources) => _et.Unguaranteed_Procedure<Parameters, Error, Resources>;
+export declare namespace pi {
     /**
      *
      * @param action upi
      */
-    const u: <Parameters, Error, Action_Error, Resources>(action: _et.Unguaranteed_Procedure<Parameters, Action_Error, Resources>, error_transform: _et.Transformer_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => _et.Unguaranteed_Procedure<Parameters, Error, Resources>;
+    const u: <Parameters, Error, Action_Error, Resources>(action: _et.Procedure<Parameters, Action_Error, Resources>, error_transform: _et.Transformer_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => _et.Procedure<Parameters, Error, Resources>;
 }
-export declare namespace uq {
+export declare namespace q {
     /**
      *
      * @param query_result qr
      * @returns
      */
-    const fixed: <Query_Result, Error>(query_result: Query_Result) => Basic_Unguaranteed_Query_Promise<Query_Result, Error>;
+    const fixed: <Query_Result, Error>(query_result: Query_Result) => Basic_Query_Promise<Query_Result, Error>;
     /**
-     * unguaranteed query
+     * query
      * @param the_query uqi
      * @param parameters u.q
      * @param result_refinement ut
@@ -97,16 +52,9 @@ export declare namespace uq {
      * @param error_handler eh
      * @returns
      */
-    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error, Resources>(the_query: _et.Unguaranteed_Query<Parameters, Query_Result, Query_Error, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources, result_refinement: _et.Refiner_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _et.Transformer_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
-    /**
-     * guaranteed query
-     * @param the_query gqi
-     * @param parameters u.q
-     * @param result_refinement ut
-     */
-    const g: <Result_After_Transformation, Error, Parameters, Query_Result, Resources>(the_query: _et.Guaranteed_Query<Parameters, Query_Result, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, result_refinement: _et.Refiner_Without_Parameters<Query_Result, Result_After_Transformation, Error>, resources: Resources) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
+    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error, Resources>(the_query: _et.Query<Parameters, Query_Result, Query_Error, Resources>, parameters: Basic_Query_Promise<Parameters, Error>, resources: Resources, result_refinement: _et.Refiner_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _et.Transformer_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Basic_Query_Promise<Result_After_Transformation, Error>;
 }
-export declare namespace ut {
+export declare namespace t {
     /**
      *
      * @param the_refinement ut

package/dist/shorthands.js

@@ -23,94 +23,19 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ut = exports.uq = exports.upi = exports.up = exports.gt = exports.gq = exports.gp = exports.eh = void 0;
+exports.t = exports.q = exports.pi = exports.p = void 0;
 const _ei = __importStar(require("exupery-core-internals"));
-const initialize_unguaranteed_procedure_1 = require("./algorithms/procedure/initialize_unguaranteed_procedure");
+const initialize_procedure_1 = require("./algorithms/procedure/initialize_procedure");
 const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_processes_monitor");
-/**
- *
- * @param action gpi
- * @param error_transform gt
- */
-const eh = (action, error_transform, resources) => {
-    return ($) => {
-        action(resources)(error_transform($)).__start(() => { });
-    };
-};
-exports.eh = eh;
-var gp;
-(function (gp) {
-    /**
-     *
-     * @param action gpi
-     * @param query g.q
-     * @returns
-     */
-    gp.action = (action, query, $r) => {
-        return {
-            __start: (on_finished) => {
-                //run the query
-                query.__start((query_result) => {
-                    //run the action
-                    action($r)(query_result).__start(on_finished);
-                });
-            }
-        };
-    };
-})(gp || (exports.gp = gp = {}));
-var gq;
-(function (gq) {
-    /**
-     *
-     * @param query_result qr
-     * @returns
-     */
-    gq.fixed = (query_result) => {
-        return {
-            __start: (on_finished) => {
-                on_finished(query_result);
-            }
-        };
-    };
-    /**
-     *
-     * @param the_query gqi
-     * @param parameters g.q
-     * @param result_transformation gt
-     * @returns
-     */
-    gq.g = (the_query, parameters, result_transformation, resources) => {
-        return {
-            __start: (on_finished) => {
-                parameters.__start((qr_in) => {
-                    the_query(resources)(qr_in).__start((result) => {
-                        on_finished(result_transformation(result));
-                    });
-                });
-            }
-        };
-    };
-})(gq || (exports.gq = gq = {}));
-var gt;
-(function (gt) {
-    /**
-     *
-     * @param the_transformation gt
-     * @returns
-     */
-    gt.g = (the_transformation) => {
-        return ($) => the_transformation($);
-    };
-})(gt || (exports.gt = gt = {}));
-var up;
-(function (up) {
+var p;
+(function (p) {
     /**
      *
      * @param action upi
      * @param query u.q
      */
-    up.action = (action, query, resources) => {
-        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    p.action = (action, query, resources) => {
+        return (0, initialize_procedure_1.__create_procedure)({
             'execute': (on_success, on_error) => {
                 //run the query
                 query.__start((query_result) => {
@@ -128,8 +53,8 @@ var up;
      * @param steps up[]
      * @returns
      */
-    up.sequence = (steps) => {
-        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    p.sequence = (steps) => {
+        return (0, initialize_procedure_1.__create_procedure)({
             'execute': (on_success, on_error) => {
                 const length = _ei.array_literal(steps).__get_number_of_elements();
                 const runStep = (index) => {
@@ -149,8 +74,8 @@ var up;
      * @param aggregate_exceptions gt
      * @returns
      */
-    up.array = (the_array, aggregate_exceptions) => {
-        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    p.array = (the_array, aggregate_exceptions) => {
+        return (0, initialize_procedure_1.__create_procedure)({
             'execute': (on_success, on_error) => {
                 const exceptions = [];
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
@@ -180,8 +105,8 @@ var up;
      * @param aggregate_exceptions gt
      * @returns
      */
-    up.dictionary = (the_dictionary, aggregate_exceptions) => {
-        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    p.dictionary = (the_dictionary, aggregate_exceptions) => {
+        return (0, initialize_procedure_1.__create_procedure)({
             'execute': (on_success, on_error) => {
                 const exceptions = {};
                 (0, create_asynchronous_processes_monitor_1.create_asynchronous_processes_monitor)((monitor) => {
@@ -205,26 +130,15 @@ var up;
             }
         });
     };
-})(up || (exports.up = up = {}));
-var upi;
-(function (upi) {
-    /**
-     *
-     * @param action gpi
-     */
-    upi.g = (action, $r) => () => ($) => {
-        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
-            'execute': (on_succes, on_error) => {
-                action($r)($).__start(on_succes);
-            }
-        });
-    };
+})(p || (exports.p = p = {}));
+var pi;
+(function (pi) {
     /**
      *
      * @param action upi
      */
-    upi.u = (action, error_transform, error_handler) => ($r) => ($) => {
-        return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
+    pi.u = (action, error_transform, error_handler) => ($r) => ($) => {
+        return (0, initialize_procedure_1.__create_procedure)({
             'execute': (on_succes, on_error) => {
                 action($r)($).__start(on_succes, (error) => {
                     if (error_handler !== undefined) {
@@ -235,15 +149,15 @@ var upi;
             }
         });
     };
-})(upi || (exports.upi = upi = {}));
-var uq;
-(function (uq) {
+})(pi || (exports.pi = pi = {}));
+var q;
+(function (q) {
     /**
      *
      * @param query_result qr
      * @returns
      */
-    uq.fixed = (query_result) => {
+    q.fixed = (query_result) => {
         return {
             __start: (on_success, on_error) => {
                 on_success(query_result);
@@ -251,7 +165,7 @@ var uq;
         };
     };
     /**
-     * unguaranteed query
+     * query
      * @param the_query uqi
      * @param parameters u.q
      * @param result_refinement ut
@@ -259,7 +173,7 @@ var uq;
      * @param error_handler eh
      * @returns
      */
-    uq.u = (the_query, parameters, resources, result_refinement, error_transform, error_handler) => {
+    q.u = (the_query, parameters, resources, result_refinement, error_transform, error_handler) => {
         return {
             __start: (on_success, on_error) => {
                 parameters.__start((qr_in) => {
@@ -275,26 +189,9 @@ var uq;
             }
         };
     };
-    /**
-     * guaranteed query
-     * @param the_query gqi
-     * @param parameters u.q
-     * @param result_refinement ut
-     */
-    uq.g = (the_query, parameters, result_refinement, resources) => {
-        return {
-            __start: (on_success, on_error) => {
-                parameters.__start((x) => {
-                    the_query(resources)(x).__start(($) => {
-                        result_refinement($).process((x) => on_success(x), on_error);
-                    });
-                }, on_error);
-            }
-        };
-    };
-})(uq || (exports.uq = uq = {}));
-var ut;
-(function (ut) {
+})(q || (exports.q = q = {}));
+var t;
+(function (t) {
     /**
      *
      * @param the_refinement ut
@@ -302,7 +199,7 @@ var ut;
      * @param error_handler  eh
      * @returns
      */
-    ut.u = (the_refinement, error_transform, error_handler) => {
+    t.u = (the_refinement, error_transform, error_handler) => {
         return ($) => {
             const result = the_refinement($);
             return result.map((out) => out, (transformation_error) => {
@@ -318,9 +215,9 @@ var ut;
      *
      * @param the_transformation gt
      */
-    ut.g = (the_transformation) => {
+    t.g = (the_transformation) => {
         return ($) => {
             return _ei.refinement.successful(the_transformation($));
         };
     };
-})(ut || (exports.ut = ut = {}));
+})(t || (exports.t = t = {}));

package/dist/types/{Basic_Unguaranteed_Query.d.ts → Basic_Query.d.ts}

@@ -1,3 +1,3 @@
-export type Basic_Unguaranteed_Query_Promise<Result, Error> = {
+export type Basic_Query_Promise<Result, Error> = {
     __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "exupery-core-async",
-  "version": "0.3.8",
+  "version": "0.3.10",
   "license": "Apache-2.0",
   "author": "Corno",
   "description": "async types for Exupery",

package/dist/algorithms/procedure/initialize_guaranteed_procedure.d.ts

@@ -1,11 +0,0 @@
-import * as _et from "exupery-core-types";
-type Executer = {
-    'execute': (on_finished: () => void) => void;
-};
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-export declare function __create_guaranted_procedure(executer: Executer): _et.Guaranteed_Procedure_Promise;
-export {};

package/dist/algorithms/procedure/initialize_guaranteed_procedure.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__create_guaranted_procedure = __create_guaranted_procedure;
-class Guaranteed_Procedure_Promise_Class {
-    constructor(executer) {
-        this.executer = executer;
-    }
-    __start(on_finished) {
-        this.executer.execute(on_finished);
-    }
-}
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-function __create_guaranted_procedure(executer) {
-    return new Guaranteed_Procedure_Promise_Class(executer);
-}

package/dist/algorithms/query/create_guaranteed_query.d.ts

@@ -1,11 +0,0 @@
-import * as _et from "exupery-core-types";
-type Executer<T> = {
-    'execute': (on_value: ($: T) => void) => void;
-};
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-export declare function __create_guaranteed_query<T>(executer: Executer<T>): _et.Guaranteed_Query_Promise<T>;
-export {};

package/dist/algorithms/query/create_guaranteed_query.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.__create_guaranteed_query = __create_guaranteed_query;
-class Guaranteed_Query_Result_Promise_Class {
-    constructor(executer) {
-        this.executer = executer;
-    }
-    map(handle_value) {
-        return __create_guaranteed_query({
-            'execute': (on_value) => {
-                this.executer.execute((value) => {
-                    on_value(handle_value(value));
-                });
-            }
-        });
-    }
-    then(handle_value) {
-        return __create_guaranteed_query({
-            'execute': (on_value) => {
-                this.executer.execute((value) => {
-                    handle_value(value).__start(on_value);
-                });
-            }
-        });
-    }
-    __start(on_value) {
-        this.executer.execute(on_value);
-    }
-}
-/**
- * returns an {@link Async_Value }
- * @param executer the function that produces the eventual value
- * @returns
- */
-function __create_guaranteed_query(executer) {
-    return new Guaranteed_Query_Result_Promise_Class(executer);
-}

package/dist/algorithms/query/merge_2_guaranteed_queries.d.ts

@@ -1,6 +0,0 @@
-import * as _et from 'exupery-core-types';
-export type Sync_Tuple_2<T1, T2> = {
-    readonly 'first': T1;
-    readonly 'second': T2;
-};
-export declare function merge_2_unguaranteed_queries<T1, T2>(first: _et.Guaranteed_Query_Promise<T1>, second: _et.Guaranteed_Query_Promise<T2>): _et.Guaranteed_Query_Promise<Sync_Tuple_2<T1, T2>>;

package/dist/algorithms/query/merge_2_guaranteed_queries.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.merge_2_unguaranteed_queries = merge_2_unguaranteed_queries;
-const create_guaranteed_query_1 = require("./create_guaranteed_query");
-function merge_2_unguaranteed_queries(first, second) {
-    return (0, create_guaranteed_query_1.__create_guaranteed_query)({
-        'execute': (on_value) => {
-            let element_1_is_set = false;
-            let element_2_is_set = false;
-            let elem1;
-            let elem2;
-            function wrap_up() {
-                if (element_1_is_set && element_2_is_set) {
-                    on_value({ first: elem1, second: elem2 });
-                }
-            }
-            first.__start((val) => {
-                elem1 = val;
-                element_1_is_set = true;
-                wrap_up();
-            });
-            second.__start((val) => {
-                elem2 = val;
-                element_2_is_set = true;
-                wrap_up();
-            });
-        }
-    });
-}

package/dist/procedure/unguaranteed_procedure_dictionary.d.ts

@@ -1,2 +0,0 @@
-import * as _et from 'exupery-core-types';
-export declare const unguaranteed_procedure_dictionary: <Error>($: _et.Dictionary<_et.Unguaranteed_Procedure_Promise<Error>>) => _et.Unguaranteed_Procedure_Promise<_et.Dictionary<Error>>;

package/dist/query/unguaranteed_query_dictionary.d.ts

@@ -1,3 +0,0 @@
-import * as _et from 'exupery-core-types';
-import { Basic_Unguaranteed_Query_Promise } from '../types/Basic_Unguaranteed_Query';
-export declare const unguaranteed_query_dictionary: <Result, Error>($: _et.Dictionary<Basic_Unguaranteed_Query_Promise<Result, Error>>) => _et.Unguaranteed_Query_Promise<_et.Dictionary<Result>, _et.Dictionary<Error>>;

package/dist/types/Basic_Guaranteed_Query.d.ts

@@ -1,3 +0,0 @@
-export type Basic_Guaranteed_Query_Promise<Result> = {
-    __start: (on_finished: (result: Result) => void) => void;
-};

package/dist/types/Basic_Unguaranteed_Query.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });