exupery-core-async 0.3.0 → 0.3.1

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

@@ -1,4 +1,4 @@
-import { Guaranteed_Procedure } from "../../types/Guaranteed_Procedure";
+import { Guaranteed_Procedure_Promise } from "../../types/Guaranteed_Procedure";
 type Executer = {
     'execute': (on_finished: () => void) => void;
 };
@@ -7,6 +7,6 @@ type Executer = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_guaranted_procedure(executer: Executer): Guaranteed_Procedure;
-export declare const initialize_no_op_guaranteed_procedure: () => Guaranteed_Procedure;
+export declare function __create_guaranted_procedure(executer: Executer): Guaranteed_Procedure_Promise;
+export declare const initialize_no_op_guaranteed_procedure: () => Guaranteed_Procedure_Promise;
 export {};

package/dist/algorithms/procedure/initialize_guaranteed_procedure.js

@@ -6,13 +6,14 @@ class Guaranteed_Procedure_Class {
     constructor(executer) {
         this.executer = executer;
     }
-    x_execute(get_action, get_parameters) {
+    x_execute(get_action, get_parameters, get_resources) {
         return __create_guaranted_procedure({
             'execute': (on_finished) => {
                 this.executer.execute(() => {
                     const action = get_action();
                     const params = get_parameters();
-                    action(params).__start(on_finished);
+                    const resources = get_resources();
+                    action(params, resources).__start(on_finished);
                 });
             }
         });

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

@@ -1,4 +1,4 @@
-import { Unguaranteed_Procedure } from "../../types/Unguaranteed_Procedure";
+import { Unguaranteed_Procedure_Promise } from "../../types/Unguaranteed_Procedure";
 /**
  * this function contains the body in which the async value or exception is executed
  * after the execution, either the on_value or on_exception callback will be called
@@ -13,6 +13,6 @@ type Executer<E> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_unguaranteed_procedure<E>(executer: Executer<E>): Unguaranteed_Procedure<E>;
-export declare const initialize_no_op_unguaranteed_procedure: <E>() => Unguaranteed_Procedure<E>;
+export declare function __create_unguaranteed_procedure<E>(executer: Executer<E>): Unguaranteed_Procedure_Promise<E>;
+export declare const initialize_no_op_unguaranteed_procedure: <E>() => Unguaranteed_Procedure_Promise<E>;
 export {};

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

@@ -1,4 +1,4 @@
-import { _Guaranteed_Query } from "../../types/Guaranteed_Query";
+import { Guaranteed_Query_Promise } from "../../types/Guaranteed_Query";
 type Executer<T> = {
     'execute': (on_value: ($: T) => void) => void;
 };
@@ -7,5 +7,5 @@ type Executer<T> = {
  * @param executer the function that produces the eventual value
  * @returns
  */
-export declare function __create_guaranteed_query<T>(executer: Executer<T>): _Guaranteed_Query<T>;
+export declare function __create_guaranteed_query<T>(executer: Executer<T>): Guaranteed_Query_Promise<T>;
 export {};

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

@@ -1,4 +1,4 @@
-import { _Unguaranteed_Query } from "../../types/Unguaranteed_Query";
+import { Unguaranteed_Query_Promise } from "../../types/Unguaranteed_Query";
 /**
  * this function contains the body in which the async value or exception is executed
  * after the execution, either the on_value or on_exception callback will be called
@@ -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>): _Unguaranteed_Query<T, E>;
+export declare function __create_unguaranteed_query<T, E>(executer: Executer<T, E>): Unguaranteed_Query_Promise<T, E>;
 export {};

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

@@ -1,6 +1,6 @@
-import { _Guaranteed_Query } from "../../types/Guaranteed_Query";
+import { Guaranteed_Query_Promise } from "../../types/Guaranteed_Query";
 export type Sync_Tuple_2<T1, T2> = {
     readonly 'first': T1;
     readonly 'second': T2;
 };
-export declare function merge_2_unguaranteed_queries<T1, T2>(first: _Guaranteed_Query<T1>, second: _Guaranteed_Query<T2>): _Guaranteed_Query<Sync_Tuple_2<T1, T2>>;
+export declare function merge_2_unguaranteed_queries<T1, T2>(first: Guaranteed_Query_Promise<T1>, second: Guaranteed_Query_Promise<T2>): Guaranteed_Query_Promise<Sync_Tuple_2<T1, T2>>;

package/dist/index.d.ts

@@ -8,25 +8,25 @@ export * from "./algorithms/query/create_unguaranteed_query";
 export * from "./algorithms/procedure/initialize_guaranteed_procedure";
 export * from "./algorithms/procedure/initialize_unguaranteed_procedure";
 export * from "./shorthands";
-import { Guaranteed_Procedure } from "./types/Guaranteed_Procedure";
-import { Unguaranteed_Procedure } from "./types/Unguaranteed_Procedure";
-import { _Guaranteed_Query } from "./types/Guaranteed_Query";
-import { _Unguaranteed_Query } from "./types/Unguaranteed_Query";
+import { Guaranteed_Procedure_Promise } from "./types/Guaranteed_Procedure";
+import { Unguaranteed_Procedure_Promise } from "./types/Unguaranteed_Procedure";
+import { Guaranteed_Query_Promise } from "./types/Guaranteed_Query";
+import { Unguaranteed_Query_Promise } from "./types/Unguaranteed_Query";
 export declare const query: {
     guaranteed: {
-        'create result': <T>($: T) => _Guaranteed_Query<T>;
+        'create result': <T>($: T) => Guaranteed_Query_Promise<T>;
     };
     unguaranteed: {
-        'create result': <T, E>($: T) => _Unguaranteed_Query<T, E>;
-        'raise exception': <T, E>($: E) => _Unguaranteed_Query<T, E>;
+        'create result': <T, E>($: T) => Unguaranteed_Query_Promise<T, E>;
+        'raise exception': <T, E>($: E) => Unguaranteed_Query_Promise<T, E>;
     };
 };
 export declare const command: {
     guaranteed: {
-        initialize: () => Guaranteed_Procedure;
+        initialize: () => Guaranteed_Procedure_Promise;
     };
     unguaranteed: {
-        initialize: <E>() => Unguaranteed_Procedure<E>;
-        'raise exception': <E>($: E) => Unguaranteed_Procedure<E>;
+        initialize: <E>() => Unguaranteed_Procedure_Promise<E>;
+        'raise exception': <E>($: E) => Unguaranteed_Procedure_Promise<E>;
     };
 };

package/dist/shorthands.d.ts

@@ -1,9 +1,9 @@
 import * as _ei from 'exupery-core-internals';
 import * as _et from 'exupery-core-types';
-import { Unguaranteed } from "./types/Unguaranteed_Query";
-import { Guaranteed } from "./types/Guaranteed_Query";
-import { Guaranteed_Procedure, Guaranteed_Procedure_Initializer } from "./types/Guaranteed_Procedure";
-import { Unguaranteed_Procedure_Initializer, Unguaranteed_Procedure } from "./types/Unguaranteed_Procedure";
+import { Basic_Unguaranteed_Query_Promise } from "./types/Unguaranteed_Query";
+import { Basic_Guaranteed_Query_Promise } from "./types/Guaranteed_Query";
+import { Guaranteed_Procedure_Promise, Guaranteed_Procedure_Initializer } from "./types/Guaranteed_Procedure";
+import { Unguaranteed_Procedure_Initializer, Unguaranteed_Procedure_Promise } from "./types/Unguaranteed_Procedure";
 import { Unguaranteed_Query_Initializer } from "./types/Unguaranteed_Query";
 import { Guaranteed_Query_Initializer } from "./types/Guaranteed_Query";
 import { Error_Handler } from "./types/Error_Handler";
@@ -12,7 +12,7 @@ import { Error_Handler } from "./types/Error_Handler";
  * @param action gpi
  * @param error_transform gt
  */
-export declare const eh: <Parameters, Error>(action: Guaranteed_Procedure_Initializer<Parameters>, error_transform: _ei.Transformation_Without_Parameters<Error, Parameters>) => Error_Handler<Error>;
+export declare const eh: <Parameters, Resources, Error>(action: Guaranteed_Procedure_Initializer<Parameters, Resources>, error_transform: _ei.Transformation_Without_Parameters<Error, Parameters>, resources: Resources) => Error_Handler<Error>;
 export declare namespace gp {
     /**
      *
@@ -20,7 +20,7 @@ export declare namespace gp {
      * @param query g.q
      * @returns
      */
-    const action: <Parameters>(action: Guaranteed_Procedure_Initializer<Parameters>, query: Guaranteed.Query_<Parameters>) => Guaranteed_Procedure;
+    const action: <Parameters, Resources>(action: Guaranteed_Procedure_Initializer<Parameters, Resources>, query: Basic_Guaranteed_Query_Promise<Parameters>, $r: Resources) => Guaranteed_Procedure_Promise;
 }
 export declare namespace gq {
     /**
@@ -28,7 +28,7 @@ export declare namespace gq {
      * @param query_result qr
      * @returns
      */
-    const fixed: <Query_Result>(query_result: Query_Result) => Guaranteed.Query_<Query_Result>;
+    const fixed: <Query_Result>(query_result: Query_Result) => Basic_Guaranteed_Query_Promise<Query_Result>;
     /**
      *
      * @param the_query gqi
@@ -36,7 +36,7 @@ export declare namespace gq {
      * @param result_transformation gt
      * @returns
      */
-    const g: <Result_After_Transformation, Parameters, Query_Result>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result>, parameters: Guaranteed.Query_<Parameters>, result_transformation: _ei.Transformation_Without_Parameters<Query_Result, Result_After_Transformation>) => Guaranteed.Query_<Result_After_Transformation>;
+    const g: <Result_After_Transformation, Parameters, Query_Result, Resources>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result, Resources>, parameters: Basic_Guaranteed_Query_Promise<Parameters>, result_transformation: _ei.Transformation_Without_Parameters<Query_Result, Result_After_Transformation>, resources: Resources) => Basic_Guaranteed_Query_Promise<Result_After_Transformation>;
 }
 export declare namespace gt {
     /**
@@ -52,39 +52,39 @@ export declare namespace up {
      * @param action upi
      * @param query u.q
      */
-    const action: <Error, Parameters>(action: Unguaranteed_Procedure_Initializer<Parameters, Error>, query: Unguaranteed.Query<Parameters, Error>) => Unguaranteed_Procedure<Error>;
+    const action: <Error, Parameters, Resources>(action: Unguaranteed_Procedure_Initializer<Parameters, Resources, Error>, query: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources) => Unguaranteed_Procedure_Promise<Error>;
     /**
      *
      * @param steps up[]
      * @returns
      */
-    const sequence: <Error>(steps: Unguaranteed_Procedure<Error>[]) => Unguaranteed_Procedure<Error>;
+    const sequence: <Error>(steps: Unguaranteed_Procedure_Promise<Error>[]) => Unguaranteed_Procedure_Promise<Error>;
     /**
      *
      * @param the_array up[]
      * @param aggregate_exceptions gt
      * @returns
      */
-    const array: <Error, Element_Error>(the_array: _et.Array<Unguaranteed_Procedure<Element_Error>>, aggregate_exceptions: _ei.Transformation_Without_Parameters<_et.Array<Element_Error>, Error>) => Unguaranteed_Procedure<Error>;
+    const array: <Error, Element_Error>(the_array: _et.Array<Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _ei.Transformation_Without_Parameters<_et.Array<Element_Error>, Error>) => Unguaranteed_Procedure_Promise<Error>;
     /**
      *
      * @param the_dictionary dict<up>
      * @param aggregate_exceptions gt
      * @returns
      */
-    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<Unguaranteed_Procedure<Element_Error>>, aggregate_exceptions: _ei.Transformation_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => Unguaranteed_Procedure<Error>;
+    const dictionary: <Error, Element_Error>(the_dictionary: _et.Dictionary<Unguaranteed_Procedure_Promise<Element_Error>>, aggregate_exceptions: _ei.Transformation_Without_Parameters<_et.Dictionary<Element_Error>, Error>) => Unguaranteed_Procedure_Promise<Error>;
 }
 export declare namespace upi {
     /**
      *
      * @param action gpi
      */
-    const g: <Parameters, Error>(action: Guaranteed_Procedure_Initializer<Parameters>) => Unguaranteed_Procedure_Initializer<Parameters, Error>;
+    const g: <Parameters, Resources, Error>(action: Guaranteed_Procedure_Initializer<Parameters, Resources>, $r: Resources) => Unguaranteed_Procedure_Initializer<Parameters, Resources, Error>;
     /**
      *
      * @param action upi
      */
-    const u: <Parameters, Error, Action_Error>(action: Unguaranteed_Procedure_Initializer<Parameters, Action_Error>, error_transform: _ei.Transformation_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => Unguaranteed_Procedure_Initializer<Parameters, Error>;
+    const u: <Parameters, Resources, Error, Action_Error>(action: Unguaranteed_Procedure_Initializer<Parameters, Resources, Action_Error>, error_transform: _ei.Transformation_Without_Parameters<Action_Error, Error>, error_handler?: Error_Handler<Action_Error>) => Unguaranteed_Procedure_Initializer<Parameters, Resources, Error>;
 }
 export declare namespace uq {
     /**
@@ -92,7 +92,7 @@ export declare namespace uq {
      * @param query_result qr
      * @returns
      */
-    const fixed: <Query_Result, Error>(query_result: Query_Result) => Unguaranteed.Query<Query_Result, Error>;
+    const fixed: <Query_Result, Error>(query_result: Query_Result) => Basic_Unguaranteed_Query_Promise<Query_Result, Error>;
     /**
      * unguaranteed query
      * @param the_query uqi
@@ -102,14 +102,14 @@ export declare namespace uq {
      * @param error_handler eh
      * @returns
      */
-    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error>(the_query: Unguaranteed_Query_Initializer<Parameters, Query_Result, Query_Error>, parameters: Unguaranteed.Query<Parameters, Error>, result_refinement: _ei.Refinement_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _ei.Transformation_Without_Parameters<Query_Error, Error>, error_handler?: Error_Handler<Query_Error>) => Unguaranteed.Query<Result_After_Transformation, Error>;
+    const u: <Result_After_Transformation, Error, Parameters, Query_Result, Query_Error, Resources>(the_query: Unguaranteed_Query_Initializer<Parameters, Query_Result, Query_Error, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, resources: Resources, result_refinement: _ei.Refinement_Without_Parameters<Query_Result, Result_After_Transformation, Error>, error_transform: _ei.Transformation_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>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result>, parameters: Unguaranteed.Query<Parameters, Error>, result_refinement: _ei.Refinement_Without_Parameters<Query_Result, Result_After_Transformation, Error>) => Unguaranteed.Query<Result_After_Transformation, Error>;
+    const g: <Result_After_Transformation, Error, Parameters, Query_Result, Resources>(the_query: Guaranteed_Query_Initializer<Parameters, Query_Result, Resources>, parameters: Basic_Unguaranteed_Query_Promise<Parameters, Error>, result_refinement: _ei.Refinement_Without_Parameters<Query_Result, Result_After_Transformation, Error>, resources: Resources) => Basic_Unguaranteed_Query_Promise<Result_After_Transformation, Error>;
 }
 export declare namespace ut {
     /**

package/dist/shorthands.js

@@ -32,9 +32,9 @@ const create_asynchronous_processes_monitor_1 = require("./create_asynchronous_p
  * @param action gpi
  * @param error_transform gt
  */
-const eh = (action, error_transform) => {
+const eh = (action, error_transform, resources) => {
     return ($) => {
-        action(error_transform($)).__start(() => { });
+        action(error_transform($), resources).__start(() => { });
     };
 };
 exports.eh = eh;
@@ -46,13 +46,13 @@ var gp;
      * @param query g.q
      * @returns
      */
-    gp.action = (action, query) => {
+    gp.action = (action, query, $r) => {
         return {
             __start: (on_finished) => {
                 //run the query
                 query.__start((query_result) => {
                     //run the action
-                    action(query_result).__start(on_finished);
+                    action(query_result, $r).__start(on_finished);
                 });
             }
         };
@@ -79,11 +79,11 @@ var gq;
      * @param result_transformation gt
      * @returns
      */
-    gq.g = (the_query, parameters, result_transformation) => {
+    gq.g = (the_query, parameters, result_transformation, resources) => {
         return {
             __start: (on_finished) => {
                 parameters.__start((qr_in) => {
-                    the_query(qr_in).__start((result) => {
+                    the_query(qr_in, resources).__start((result) => {
                         on_finished(result_transformation(result));
                     });
                 });
@@ -109,13 +109,13 @@ var up;
      * @param action upi
      * @param query u.q
      */
-    up.action = (action, query) => {
+    up.action = (action, query, resources) => {
         return {
             __start: (on_success, on_error) => {
                 //run the query
                 query.__start((query_result) => {
                     //run the action
-                    action(query_result).__start(on_success, (error) => {
+                    action(query_result, resources).__start(on_success, (error) => {
                         //transform the error
                         on_error(error);
                     });
@@ -212,10 +212,10 @@ var upi;
      *
      * @param action gpi
      */
-    upi.g = (action) => ($) => {
+    upi.g = (action, $r) => ($) => {
         return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
             'execute': (on_succes, on_error) => {
-                action($).__start(on_succes);
+                action($, $r).__start(on_succes);
             }
         });
     };
@@ -223,10 +223,10 @@ var upi;
      *
      * @param action upi
      */
-    upi.u = (action, error_transform, error_handler) => ($) => {
+    upi.u = (action, error_transform, error_handler) => ($, $r) => {
         return (0, initialize_unguaranteed_procedure_1.__create_unguaranteed_procedure)({
             'execute': (on_succes, on_error) => {
-                action($).__start(on_succes, (error) => {
+                action($, $r).__start(on_succes, (error) => {
                     if (error_handler !== undefined) {
                         error_handler(error);
                     }
@@ -259,11 +259,11 @@ var uq;
      * @param error_handler eh
      * @returns
      */
-    uq.u = (the_query, parameters, result_refinement, error_transform, error_handler) => {
+    uq.u = (the_query, parameters, resources, result_refinement, error_transform, error_handler) => {
         return {
             __start: (on_success, on_error) => {
                 parameters.__start((qr_in) => {
-                    the_query(qr_in).__start((result) => {
+                    the_query(qr_in, resources).__start((result) => {
                         result_refinement(result).process((x) => on_success(x), on_error);
                     }, (error) => {
                         if (error_handler !== undefined) {
@@ -281,11 +281,11 @@ var uq;
      * @param parameters u.q
      * @param result_refinement ut
      */
-    uq.g = (the_query, parameters, result_refinement) => {
+    uq.g = (the_query, parameters, result_refinement, resources) => {
         return {
             __start: (on_success, on_error) => {
                 parameters.__start((x) => {
-                    the_query(x).__start(($) => {
+                    the_query(x, resources).__start(($) => {
                         result_refinement($).process((x) => on_success(x), on_error);
                     });
                 }, on_error);

package/dist/types/Guaranteed_Procedure.d.ts

@@ -1,4 +1,4 @@
-export type Guaranteed_Procedure_Initializer<Parameters> = ($: Parameters) => Guaranteed_Procedure;
-export interface Guaranteed_Procedure {
+export type Guaranteed_Procedure_Initializer<Parameters, Resources> = ($: Parameters, $r: Resources) => Guaranteed_Procedure_Promise;
+export interface Guaranteed_Procedure_Promise {
     __start: (on_finished: () => void) => void;
 }

package/dist/types/Guaranteed_Query.d.ts

@@ -1,22 +1,20 @@
+export type Guaranteed_Query_Initializer<Parameters, Result, Resources> = ($: Parameters, $r: Resources) => Guaranteed_Query_Promise<Result>;
 /**
  * A value that will asynchronously become available.
  * Similar to the concept of a promise, but with a smaller API.
  */
-export interface _Guaranteed_Query<T> {
-    map<NT>(handle_value: ($: T) => NT): _Guaranteed_Query<NT>;
+export type Guaranteed_Query_Promise<Result> = {
+    map<NT>(handle_value: ($: Result) => NT): Guaranteed_Query_Promise<NT>;
     /**
      * maps the current async value into a new async value
      * @param handle_value callback that transforms the actual value into a new Async_Value
      */
-    then<NT>(handle_value: ($: T) => _Guaranteed_Query<NT>): _Guaranteed_Query<NT>;
+    then<NT>(handle_value: ($: Result) => Guaranteed_Query_Promise<NT>): Guaranteed_Query_Promise<NT>;
     /**
      * This method is only to be used by resources
      */
-    __start(on_value: ($: T) => void): void;
-}
-export type Guaranteed_Query_Initializer<Parameters, Result> = ($: Parameters) => _Guaranteed_Query<Result>;
-export declare namespace Guaranteed {
-    type Query_<Result> = {
-        __start: (on_finished: (result: Result) => void) => void;
-    };
-}
+    __start(on_finished: ($: Result) => void): void;
+};
+export type Basic_Guaranteed_Query_Promise<Result> = {
+    __start: (on_finished: (result: Result) => void) => void;
+};

package/dist/types/Unguaranteed_Procedure.d.ts

@@ -1,4 +1,4 @@
-export type Unguaranteed_Procedure_Initializer<Parameters, Error> = ($: Parameters) => Unguaranteed_Procedure<Error>;
-export interface Unguaranteed_Procedure<Error> {
+export type Unguaranteed_Procedure_Initializer<Parameters, Resources, Error> = ($: Parameters, $r: Resources) => Unguaranteed_Procedure_Promise<Error>;
+export interface Unguaranteed_Procedure_Promise<Error> {
     __start: (on_success: () => void, on_error: (error: Error) => void) => void;
 }

package/dist/types/Unguaranteed_Query.d.ts

@@ -1,15 +1,13 @@
-import { _Guaranteed_Query } from "./Guaranteed_Query";
-export interface _Unguaranteed_Query<T, E> {
-    map_<NT>(handle_value: ($: T) => NT): _Unguaranteed_Query<NT, E>;
-    map_exception_<NE>(handle_exception: ($: E) => NE): _Unguaranteed_Query<T, NE>;
-    then<NT>(handle_value: ($: T) => _Guaranteed_Query<NT>): _Unguaranteed_Query<NT, E>;
-    then_unguaranteed<NT>(handle_value: ($: T) => _Unguaranteed_Query<NT, E>): _Unguaranteed_Query<NT, E>;
-    catch_(handle_exception: ($: E) => _Guaranteed_Query<T>): _Guaranteed_Query<T>;
-    __start(on_value: ($: T) => void, on_exception: ($: E) => void): void;
-}
-export type Unguaranteed_Query_Initializer<Parameters, Result, Error> = ($: Parameters) => _Unguaranteed_Query<Result, Error>;
-export declare namespace Unguaranteed {
-    type Query<Result, Error> = {
-        __start: (on_success: (result: Result) => void, on_error: (error: Error) => void) => void;
-    };
-}
+import { Guaranteed_Query_Promise } from "./Guaranteed_Query";
+export type Unguaranteed_Query_Initializer<Parameters, Result, Error, Resources> = ($: Parameters, $r: Resources) => Unguaranteed_Query_Promise<Result, Error>;
+export type Unguaranteed_Query_Promise<Result, Error> = {
+    map_<NT>(handle_value: ($: Result) => NT): Unguaranteed_Query_Promise<NT, Error>;
+    map_exception_<NE>(handle_exception: ($: Error) => NE): Unguaranteed_Query_Promise<Result, NE>;
+    then<NT>(handle_value: ($: Result) => Guaranteed_Query_Promise<NT>): Unguaranteed_Query_Promise<NT, Error>;
+    then_unguaranteed<NT>(handle_value: ($: Result) => Unguaranteed_Query_Promise<NT, Error>): Unguaranteed_Query_Promise<NT, Error>;
+    catch_(handle_exception: ($: Error) => Guaranteed_Query_Promise<Result>): Guaranteed_Query_Promise<Result>;
+    __start(on_success: ($: Result) => void, on_error: ($: Error) => void): void;
+};
+export type Basic_Unguaranteed_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.0",
+  "version": "0.3.1",
   "license": "Apache-2.0",
   "author": "Corno",
   "description": "async types for Exupery",