ballerina-core 1.0.199 → 1.0.201

package/bin/src/fun/domains/updater/domains/orderedSetUpdater/state.js

@@ -1,9 +1,21 @@
 import { Fun } from "../../../../state";
 import { Updater } from "../../state";
 export const orderedSetUpdater = () => (field, displayName) => ({
-    [displayName]: {
-        add: Fun((value) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].add(value) })))),
-        remove: Fun((value) => Updater((entity) => (Object.assign(Object.assign({}, entity), { [field]: entity[field].remove(value) })))),
-    },
+  [displayName]: {
+    add: Fun((value) =>
+      Updater((entity) =>
+        Object.assign(Object.assign({}, entity), {
+          [field]: entity[field].add(value),
+        }),
+      ),
+    ),
+    remove: Fun((value) =>
+      Updater((entity) =>
+        Object.assign(Object.assign({}, entity), {
+          [field]: entity[field].remove(value),
+        }),
+      ),
+    ),
+  },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/replaceWith/state.d.ts

@@ -1,3 +1,3 @@
 import { Updater } from "../../state";
 export declare const replaceWith: <V>(v: V) => Updater<V>;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/replaceWith/state.js

@@ -1,3 +1,3 @@
 import { Updater } from "../../state";
 export const replaceWith = (v) => Updater((_) => v);
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/simpleUpdater/domains/baseSimpleUpdater/state.d.ts

@@ -1,8 +1,17 @@
 import { Fun } from "../../../../../../state";
 import { BasicUpdater, Updater } from "../../../../state";
 export type BaseWidening<c, p extends c> = Fun<BasicUpdater<c>, Updater<p>>;
-export type BaseSimpleUpdater<BaseEntity, Entity extends BaseEntity, Name extends string> = Required<{
-    [_ in Name]: BaseWidening<BaseEntity, Entity>;
+export type BaseSimpleUpdater<
+  BaseEntity,
+  Entity extends BaseEntity,
+  Name extends string,
+> = Required<{
+  [_ in Name]: BaseWidening<BaseEntity, Entity>;
 }>;
-export declare const baseSimpleUpdater: <BaseEntity, Entity extends BaseEntity>() => <Name extends string>(name: Name) => BaseSimpleUpdater<BaseEntity, Entity, Name>;
-//# sourceMappingURL=state.d.ts.map
+export declare const baseSimpleUpdater: <
+  BaseEntity,
+  Entity extends BaseEntity,
+>() => <Name extends string>(
+  name: Name,
+) => BaseSimpleUpdater<BaseEntity, Entity, Name>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/simpleUpdater/domains/baseSimpleUpdater/state.js

@@ -1,8 +1,10 @@
 import { Fun } from "../../../../../../state";
 import { Updater } from "../../../../state";
 export const baseSimpleUpdater = () => (name) => ({
-    [name]: Fun((baseUpdater) => {
-        return Updater((current) => (Object.assign(Object.assign({}, current), baseUpdater(current))));
-    }),
+  [name]: Fun((baseUpdater) => {
+    return Updater((current) =>
+      Object.assign(Object.assign({}, current), baseUpdater(current)),
+    );
+  }),
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/domains/simpleUpdater/state.d.ts

@@ -1,34 +1,72 @@
 import { Fun } from "../../../../state";
 import { Unit } from "../../../unit/state";
 import { BasicUpdater, Updater } from "../../state";
-export type Widening<p, c extends keyof p> = Fun<BasicUpdater<p[c]>, Updater<p>>;
+export type Widening<p, c extends keyof p> = Fun<
+  BasicUpdater<p[c]>,
+  Updater<p>
+>;
 export type SimpleUpdater<Entity, Field extends keyof Entity> = Required<{
-    [f in Field]: Widening<Entity, Field>;
+  [f in Field]: Widening<Entity, Field>;
 }>;
-export declare const simpleUpdater: <Entity>() => <Field extends keyof Entity>(field: Field) => SimpleUpdater<Entity, Field>;
+export declare const simpleUpdater: <Entity>() => <Field extends keyof Entity>(
+  field: Field,
+) => SimpleUpdater<Entity, Field>;
 export type WidenedChildren<p, children> = {
-    [k in Exclude<keyof children, "Core" | "Template" | "Coroutine">]: children[k] extends WideningWithChildren<infer child, infer nephew, infer nephews> ? Fun<BasicUpdater<child[nephew]>, Updater<p>> & {
+  [k in Exclude<
+    keyof children,
+    "Core" | "Template" | "Coroutine"
+  >]: children[k] extends WideningWithChildren<
+    infer child,
+    infer nephew,
+    infer nephews
+  >
+    ? Fun<BasicUpdater<child[nephew]>, Updater<p>> & {
         children: WidenedChildren<p, nephews>;
-    } : children[k] extends Widening<infer child, infer nephew> ? Fun<BasicUpdater<child[nephew]>, Updater<p>> : "cannot invoke custom updaters through automated nesting";
+      }
+    : children[k] extends Widening<infer child, infer nephew>
+      ? Fun<BasicUpdater<child[nephew]>, Updater<p>>
+      : "cannot invoke custom updaters through automated nesting";
 } & (children extends {
-    Core: Unit;
-} ? {
-    Core: WidenedChildren<p, children["Core"]>;
-} : Unit) & (children extends {
+  Core: Unit;
+}
+  ? {
+      Core: WidenedChildren<p, children["Core"]>;
+    }
+  : Unit) &
+  (children extends {
     Template: Unit;
-} ? {
-    Template: WidenedChildren<p, children["Template"]>;
-} : Unit) & (children extends {
+  }
+    ? {
+        Template: WidenedChildren<p, children["Template"]>;
+      }
+    : Unit) &
+  (children extends {
     Coroutine: Unit;
-} ? {
-    Coroutine: WidenedChildren<p, children["Coroutine"]>;
-} : Unit);
-export type WideningWithChildren<p, c extends keyof p, children> = Fun<BasicUpdater<p[c]>, Updater<p>> & {
-    children: WidenedChildren<p, children>;
+  }
+    ? {
+        Coroutine: WidenedChildren<p, children["Coroutine"]>;
+      }
+    : Unit);
+export type WideningWithChildren<p, c extends keyof p, children> = Fun<
+  BasicUpdater<p[c]>,
+  Updater<p>
+> & {
+  children: WidenedChildren<p, children>;
 };
-export type SimpleUpdaterWithChildren<Entity, Field extends keyof Entity, children> = {
-    [f in Field]: WideningWithChildren<Entity, Field, children>;
+export type SimpleUpdaterWithChildren<
+  Entity,
+  Field extends keyof Entity,
+  children,
+> = {
+  [f in Field]: WideningWithChildren<Entity, Field, children>;
 };
-export declare const simpleUpdaterWithChildren: <Entity>() => <children>(children: children) => <Field extends keyof Entity>(field: Field) => SimpleUpdaterWithChildren<Entity, Field, children>;
-export declare const widenChildren: <p, child, children>(childToParent: Fun<BasicUpdater<child>, Updater<p>>, children: children) => WidenedChildren<p, children>;
-//# sourceMappingURL=state.d.ts.map
+export declare const simpleUpdaterWithChildren: <Entity>() => <children>(
+  children: children,
+) => <Field extends keyof Entity>(
+  field: Field,
+) => SimpleUpdaterWithChildren<Entity, Field, children>;
+export declare const widenChildren: <p, child, children>(
+  childToParent: Fun<BasicUpdater<child>, Updater<p>>,
+  children: children,
+) => WidenedChildren<p, children>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/domains/simpleUpdater/state.js

@@ -1,40 +1,51 @@
 import { Fun } from "../../../../state";
 import { Updater } from "../../state";
 export const simpleUpdater = () => (field) => ({
-    [field]: Fun((fieldUpdater) => {
-        return Updater((currentEntity) => (Object.assign(Object.assign({}, currentEntity), { [field]: fieldUpdater(currentEntity[field]) })));
-    }),
+  [field]: Fun((fieldUpdater) => {
+    return Updater((currentEntity) =>
+      Object.assign(Object.assign({}, currentEntity), {
+        [field]: fieldUpdater(currentEntity[field]),
+      }),
+    );
+  }),
 });
 export const simpleUpdaterWithChildren = () => (children) => (field) => ({
-    [field]: Object.assign(Fun((fieldUpdater) => {
-        const basicUpdater = (currentEntity) => (Object.assign(Object.assign({}, currentEntity), { [field]: fieldUpdater(currentEntity[field]) }));
-        return Updater(basicUpdater);
-    }), {
-        children: widenChildren(simpleUpdater()(field)[field], children),
+  [field]: Object.assign(
+    Fun((fieldUpdater) => {
+      const basicUpdater = (currentEntity) =>
+        Object.assign(Object.assign({}, currentEntity), {
+          [field]: fieldUpdater(currentEntity[field]),
+        });
+      return Updater(basicUpdater);
     }),
+    {
+      children: widenChildren(simpleUpdater()(field)[field], children),
+    },
+  ),
 });
 export const widenChildren = (childToParent, children) => {
-    if (children == undefined)
-        return {};
-    const result = {};
-    Object.keys(children).forEach((key) => {
-        if (key == "Core" || key == "Template" || key == "Coroutine")
-            return;
-        // Fun<BasicUpdater<child[key]>, Updater<child>>
-        const fieldOfChildUpdater = children[key];
-        result[key] = Fun((_) => childToParent(fieldOfChildUpdater(_)));
-        if (Object.keys(fieldOfChildUpdater).includes("children")) {
-            result[key]["children"] = widenChildren(childToParent, fieldOfChildUpdater["children"]);
-        }
-    });
-    const updateBlock = (block) => {
-        if (children[block] != undefined) {
-            result[block] = widenChildren(childToParent, children[block]);
-        }
-    };
-    updateBlock("Core");
-    updateBlock("Template");
-    updateBlock("Coroutines");
-    return result;
+  if (children == undefined) return {};
+  const result = {};
+  Object.keys(children).forEach((key) => {
+    if (key == "Core" || key == "Template" || key == "Coroutine") return;
+    // Fun<BasicUpdater<child[key]>, Updater<child>>
+    const fieldOfChildUpdater = children[key];
+    result[key] = Fun((_) => childToParent(fieldOfChildUpdater(_)));
+    if (Object.keys(fieldOfChildUpdater).includes("children")) {
+      result[key]["children"] = widenChildren(
+        childToParent,
+        fieldOfChildUpdater["children"],
+      );
+    }
+  });
+  const updateBlock = (block) => {
+    if (children[block] != undefined) {
+      result[block] = widenChildren(childToParent, children[block]);
+    }
+  };
+  updateBlock("Core");
+  updateBlock("Template");
+  updateBlock("Coroutines");
+  return result;
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/domains/updater/state.d.ts

@@ -1,9 +1,9 @@
 import { BasicFun, Fun } from "../../state";
 export type BasicUpdater<e> = BasicFun<e, e>;
 export type Updater<e> = BasicUpdater<e> & {
-    fun: Fun<e, e>;
-    then(other: BasicUpdater<e>): Updater<e>;
-    thenMany(others: Array<BasicUpdater<e>>): Updater<e>;
+  fun: Fun<e, e>;
+  then(other: BasicUpdater<e>): Updater<e>;
+  thenMany(others: Array<BasicUpdater<e>>): Updater<e>;
 };
 export declare const Updater: <e>(u: BasicUpdater<e>) => Updater<e>;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/domains/updater/state.js

@@ -1,14 +1,16 @@
 import { Fun } from "../../state";
 export const Updater = (u) => {
-    return Object.assign(u, {
-        fun: Fun(u),
-        then: function (other) {
-            return Updater((_) => other(this(_)));
-        },
-        thenMany: function (others) {
-            return Updater(others.map((_) => Updater(_)).reduce((f, g) => f.then(g), this));
-        },
-    });
+  return Object.assign(u, {
+    fun: Fun(u),
+    then: function (other) {
+      return Updater((_) => other(this(_)));
+    },
+    thenMany: function (others) {
+      return Updater(
+        others.map((_) => Updater(_)).reduce((f, g) => f.then(g), this),
+      );
+    },
+  });
 };
 /*export const Updater = Object.assign(<e>(_: BasicUpdater<e>): Updater<e> => {
   const u = _ as Updater<e>;
@@ -73,4 +75,4 @@ const personAndAddressUpdater:Updater<Person> =
     Person.Updaters.Core.address.children.Core.city.Core.name(_ => `${_} the Great`)
     )
 */
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/fun/state.d.ts

@@ -1,11 +1,11 @@
 export type BasicFun<a, b> = (_: a) => b;
 export type Fun<a, b> = BasicFun<a, b> & {
-    then<c>(other: BasicFun<b, c>): Fun<a, c>;
+  then<c>(other: BasicFun<b, c>): Fun<a, c>;
 };
 export declare const Fun: <a, b>(_: BasicFun<a, b>) => Fun<a, b>;
 export type BasicFun2<a, b, c> = (_: a, __: b) => c;
 export type Fun2<a, b, c> = BasicFun2<a, b, c> & {
-    then<d>(other: BasicFun<c, d>): Fun2<a, b, d>;
+  then<d>(other: BasicFun<c, d>): Fun2<a, b, d>;
 };
 export declare const Fun2: <a, b, c>(_: BasicFun2<a, b, c>) => Fun2<a, b, c>;
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/fun/state.js

@@ -1,13 +1,15 @@
-export const Fun = (_) => Object.assign(_, {
+export const Fun = (_) =>
+  Object.assign(_, {
     then: function (other) {
-        return Fun((_) => other(this(_)));
+      return Fun((_) => other(this(_)));
     },
-});
-export const Fun2 = (_) => Object.assign(_, {
+  });
+export const Fun2 = (_) =>
+  Object.assign(_, {
     then: function (other) {
-        return Fun2((a, b) => other(this(a, b)));
+      return Fun2((a, b) => other(this(a, b)));
     },
-});
+  });
 /*
 // samples
 const incr: Fun<number,number> = Fun(_ => _ + 1)
@@ -18,4 +20,4 @@ const halv: Fun<number,number> = Fun(_ => _ / 2)
 const f = incr.then(doub).then(decr)
 console.log(f(5)) // prints 11
 */
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/infinite-data-stream/coroutines/builder.d.ts

@@ -1,30 +1,212 @@
 import { InfiniteStreamWritableState } from "../state";
-export declare const StreamCo: <Element extends {
+export declare const StreamCo: <
+  Element extends {
     Id: string;
-}>() => {
-    Seq: (ps: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>[]) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    GetState: () => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>>;
-    SetState: (stateUpdater: import("../../../main").BasicUpdater<InfiniteStreamWritableState<Element>>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    UpdateState: (stateUpdater: import("../../fun/state").BasicFun<InfiniteStreamWritableState<Element>, import("../../../main").BasicUpdater<InfiniteStreamWritableState<Element>>>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    Any: (ps: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>[]) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    All: <result>(ps: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, result>[]) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, result[]>;
-    Yield: (next: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    Wait: (ms: number) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    Await: <r, err>(p: import("../../fun/state").BasicFun<import("../../../main").Unit, Promise<r>>, onErr: import("../../fun/state").BasicFun<any, err>, debugName?: string) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Sum<r, err>>;
-    Repeat: (p: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    Return: <r>(res: r) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, r>;
-    While: (predicate: import("../../fun/state").BasicFun<[InfiniteStreamWritableState<Element>], boolean>, p: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    For: <element>(collection: import("immutable").Collection<number, element>) => (p: import("../../fun/state").BasicFun<element, import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
-    Embed: <parentContext, parentState, result>(p: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, result>, narrow: import("../../fun/state").BasicFun<parentContext & parentState, InfiniteStreamWritableState<Element>>, widen: import("../../fun/state").BasicFun<import("../../../main").BasicUpdater<InfiniteStreamWritableState<Element>>, import("../../../main").BasicUpdater<parentState>>) => import("../../coroutines/state").Coroutine<parentContext & parentState, parentState, result>;
-    Template: <fm>(initialCoroutine: import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>, options?: import("../../coroutines/template").CoroutineComponentOptions<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>> | undefined) => import("../../template/state").Template<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, fm>;
-    Trigger: <event_1 extends {
-        id: import("../../../main").Guid;
-        kind: kind;
-    }, kind extends string>(event: event_1) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element> & {
-        outboundEvents: import("immutable").Map<kind, import("immutable").OrderedMap<string, event_1>>;
-    }, InfiniteStreamWritableState<Element> & {
-        outboundEvents: import("immutable").Map<kind, import("immutable").OrderedMap<string, event_1>>;
-    }, import("../../../main").Unit>;
-    Do: (action: import("../../../main").SimpleCallback<void>) => import("../../coroutines/state").Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, import("../../../main").Unit>;
+  },
+>() => {
+  Seq: (
+    ps: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").Unit
+    >[],
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  GetState: () => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>
+  >;
+  SetState: (
+    stateUpdater: import("../../../main").BasicUpdater<
+      InfiniteStreamWritableState<Element>
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  UpdateState: (
+    stateUpdater: import("../../fun/state").BasicFun<
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").BasicUpdater<InfiniteStreamWritableState<Element>>
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  Any: (
+    ps: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").Unit
+    >[],
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  All: <result>(
+    ps: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      result
+    >[],
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    result[]
+  >;
+  Yield: (
+    next: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").Unit
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  Wait: (
+    ms: number,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  Await: <r, err>(
+    p: import("../../fun/state").BasicFun<
+      import("../../../main").Unit,
+      Promise<r>
+    >,
+    onErr: import("../../fun/state").BasicFun<any, err>,
+    debugName?: string,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Sum<r, err>
+  >;
+  Repeat: (
+    p: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").Unit
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  Return: <r>(
+    res: r,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    r
+  >;
+  While: (
+    predicate: import("../../fun/state").BasicFun<
+      [InfiniteStreamWritableState<Element>],
+      boolean
+    >,
+    p: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").Unit
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  For: <element>(
+    collection: import("immutable").Collection<number, element>,
+  ) => (
+    p: import("../../fun/state").BasicFun<
+      element,
+      import("../../coroutines/state").Coroutine<
+        InfiniteStreamWritableState<Element>,
+        InfiniteStreamWritableState<Element>,
+        import("../../../main").Unit
+      >
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
+  Embed: <parentContext, parentState, result>(
+    p: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      result
+    >,
+    narrow: import("../../fun/state").BasicFun<
+      parentContext & parentState,
+      InfiniteStreamWritableState<Element>
+    >,
+    widen: import("../../fun/state").BasicFun<
+      import("../../../main").BasicUpdater<
+        InfiniteStreamWritableState<Element>
+      >,
+      import("../../../main").BasicUpdater<parentState>
+    >,
+  ) => import("../../coroutines/state").Coroutine<
+    parentContext & parentState,
+    parentState,
+    result
+  >;
+  Template: <fm>(
+    initialCoroutine: import("../../coroutines/state").Coroutine<
+      InfiniteStreamWritableState<Element>,
+      InfiniteStreamWritableState<Element>,
+      import("../../../main").Unit
+    >,
+    options?:
+      | import("../../coroutines/template").CoroutineComponentOptions<
+          InfiniteStreamWritableState<Element>,
+          InfiniteStreamWritableState<Element>
+        >
+      | undefined,
+  ) => import("../../template/state").Template<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    fm
+  >;
+  Trigger: <
+    event_1 extends {
+      id: import("../../../main").Guid;
+      kind: kind;
+    },
+    kind extends string,
+  >(
+    event: event_1,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element> & {
+      outboundEvents: import("immutable").Map<
+        kind,
+        import("immutable").OrderedMap<string, event_1>
+      >;
+    },
+    InfiniteStreamWritableState<Element> & {
+      outboundEvents: import("immutable").Map<
+        kind,
+        import("immutable").OrderedMap<string, event_1>
+      >;
+    },
+    import("../../../main").Unit
+  >;
+  Do: (
+    action: import("../../../main").SimpleCallback<void>,
+  ) => import("../../coroutines/state").Coroutine<
+    InfiniteStreamWritableState<Element>,
+    InfiniteStreamWritableState<Element>,
+    import("../../../main").Unit
+  >;
 };
-//# sourceMappingURL=builder.d.ts.map
+//# sourceMappingURL=builder.d.ts.map

package/bin/src/infinite-data-stream/coroutines/builder.js

@@ -1,3 +1,3 @@
 import { CoTypedFactory } from "../../coroutines/builder";
 export const StreamCo = () => CoTypedFactory();
-//# sourceMappingURL=builder.js.map
+//# sourceMappingURL=builder.js.map

package/bin/src/infinite-data-stream/coroutines/infiniteLoader.d.ts

@@ -1,10 +1,26 @@
 import { Coroutine } from "../../coroutines/state";
 import { Unit } from "../../fun/domains/unit/state";
 import { InfiniteStreamWritableState } from "../state";
-export declare const InfiniteStreamLoader: <Element extends {
+export declare const InfiniteStreamLoader: <
+  Element extends {
     Id: string;
-}>(maxRetries?: number) => Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, Unit>;
-export declare const Loader: <Element extends {
+  },
+>(
+  maxRetries?: number,
+) => Coroutine<
+  InfiniteStreamWritableState<Element>,
+  InfiniteStreamWritableState<Element>,
+  Unit
+>;
+export declare const Loader: <
+  Element extends {
     Id: string;
-}>(maxRetries?: number) => Coroutine<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, Unit>;
-//# sourceMappingURL=infiniteLoader.d.ts.map
+  },
+>(
+  maxRetries?: number,
+) => Coroutine<
+  InfiniteStreamWritableState<Element>,
+  InfiniteStreamWritableState<Element>,
+  Unit
+>;
+//# sourceMappingURL=infiniteLoader.d.ts.map