ballerina-core 1.0.220 → 1.0.221

package/bin/src/async/domains/synchronized/coroutines/synchronize.d.ts

@@ -1,9 +1,34 @@
 import { BasicUpdater } from "../../../../../main";
-import { ApiResultStatus, ErrorPermanenceStatus } from "../../../../apiResultStatus/state";
+import {
+  ApiResultStatus,
+  ErrorPermanenceStatus,
+} from "../../../../apiResultStatus/state";
 import { Coroutine } from "../../../../coroutines/state";
 import { Unit } from "../../../../fun/domains/unit/state";
 import { BasicFun } from "../../../../fun/state";
 import { Synchronized } from "../state";
-export declare const Synchronize: <value, syncResult, context = Unit>(p: BasicFun<value & context, Promise<syncResult>>, errorProcessor?: BasicFun<any, ErrorPermanenceStatus>, maxAttempts?: number, delayBetweenAttemptsInMs?: number) => Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus>;
-export declare const SynchronizeWithValueUpdater: <value, syncResult, context = Unit>(p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>, errorProcessor?: BasicFun<any, ErrorPermanenceStatus>, maxAttempts?: number, delayBetweenAttemptsInMs?: number) => Coroutine<Synchronized<value, syncResult> & context, Synchronized<value, syncResult>, ApiResultStatus>;
-//# sourceMappingURL=synchronize.d.ts.map
+export declare const Synchronize: <value, syncResult, context = Unit>(
+  p: BasicFun<value & context, Promise<syncResult>>,
+  errorProcessor?: BasicFun<any, ErrorPermanenceStatus>,
+  maxAttempts?: number,
+  delayBetweenAttemptsInMs?: number,
+) => Coroutine<
+  Synchronized<value, syncResult> & context,
+  Synchronized<value, syncResult>,
+  ApiResultStatus
+>;
+export declare const SynchronizeWithValueUpdater: <
+  value,
+  syncResult,
+  context = Unit,
+>(
+  p: BasicFun<value & context, Promise<[syncResult, BasicUpdater<value>]>>,
+  errorProcessor?: BasicFun<any, ErrorPermanenceStatus>,
+  maxAttempts?: number,
+  delayBetweenAttemptsInMs?: number,
+) => Coroutine<
+  Synchronized<value, syncResult> & context,
+  Synchronized<value, syncResult>,
+  ApiResultStatus
+>;
+//# sourceMappingURL=synchronize.d.ts.map

package/bin/src/collections/domains/immutable/domains/list/state.d.ts

@@ -4,19 +4,23 @@ import { BasicFun } from "../../../../../fun/state";
 import { Option } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export declare const ListRepo: {
-    Default: {};
-    Updaters: {
-        remove<V>(elementIndex: number): Updater<List<V>>;
-        push<V>(v: V): Updater<List<V>>;
-        insert<V>(elementIndex: number, v: V): Updater<List<V>>;
-        update<V>(elementIndex: number, upd: Updater<V>): Updater<List<V>>;
-        filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>>;
-        move<V>(elementIndex: number, to: number): Updater<List<V>>;
-        duplicate<V>(elementIndex: number): Updater<List<V>>;
-    };
-    Operations: {
-        tryFind: <V>(elementIndex: number, list: List<V>) => Option<V>;
-        tryFindWithError: <v, e>(i: number, m: List<v>, e: () => e) => ValueOrErrors<v, e>;
-    };
+  Default: {};
+  Updaters: {
+    remove<V>(elementIndex: number): Updater<List<V>>;
+    push<V>(v: V): Updater<List<V>>;
+    insert<V>(elementIndex: number, v: V): Updater<List<V>>;
+    update<V>(elementIndex: number, upd: Updater<V>): Updater<List<V>>;
+    filter<V>(predicate: BasicFun<V, boolean>): Updater<List<V>>;
+    move<V>(elementIndex: number, to: number): Updater<List<V>>;
+    duplicate<V>(elementIndex: number): Updater<List<V>>;
+  };
+  Operations: {
+    tryFind: <V>(elementIndex: number, list: List<V>) => Option<V>;
+    tryFindWithError: <v, e>(
+      i: number,
+      m: List<v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/map/state.d.ts

@@ -1,24 +1,38 @@
 import { Map } from "immutable";
 import { Identifiable } from "../../../../../baseEntity/domains/identifiable/state";
 import { Unit } from "../../../../../fun/domains/unit/state";
-import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import {
+  BasicUpdater,
+  Updater,
+} from "../../../../../fun/domains/updater/state";
 import { BasicFun } from "../../../../../fun/state";
 import { Option } from "../../../sum/state";
 import { ValueOrErrors } from "../../../valueOrErrors/state";
 export declare const MapRepo: {
-    Default: {
-        fromIdentifiables: <T extends Identifiable>(array: T[]) => Map<T["Id"], T>;
-    };
-    Updaters: {
-        set<K, V>(key: K, value: V): Updater<Map<K, V>>;
-        remove<K, V>(key: K): Updater<Map<K, V>>;
-        update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<Map<k, v>>;
-        upsert: <k, v>(k: k, defaultValue: BasicFun<Unit, v>, _: BasicUpdater<v>) => Updater<Map<k, v>>;
-    };
-    Operations: {
-        tryFirstWithError: <k, v, e>(m: Map<k, v>, e: () => e) => ValueOrErrors<v, e>;
-        tryFind: <k, v>(k: k, m: Map<k, v>) => Option<v>;
-        tryFindWithError: <k, v, e>(k: k, m: Map<k, v>, e: () => e) => ValueOrErrors<v, e>;
-    };
+  Default: {
+    fromIdentifiables: <T extends Identifiable>(array: T[]) => Map<T["Id"], T>;
+  };
+  Updaters: {
+    set<K, V>(key: K, value: V): Updater<Map<K, V>>;
+    remove<K, V>(key: K): Updater<Map<K, V>>;
+    update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<Map<k, v>>;
+    upsert: <k, v>(
+      k: k,
+      defaultValue: BasicFun<Unit, v>,
+      _: BasicUpdater<v>,
+    ) => Updater<Map<k, v>>;
+  };
+  Operations: {
+    tryFirstWithError: <k, v, e>(
+      m: Map<k, v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+    tryFind: <k, v>(k: k, m: Map<k, v>) => Option<v>;
+    tryFindWithError: <k, v, e>(
+      k: k,
+      m: Map<k, v>,
+      e: () => e,
+    ) => ValueOrErrors<v, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/immutable/domains/orderedMap/state.d.ts

@@ -1,30 +1,58 @@
 import { OrderedMap } from "immutable";
-import { Identifiable, SmallIdentifiable } from "../../../../../baseEntity/domains/identifiable/state";
-import { BasicUpdater, Updater } from "../../../../../fun/domains/updater/state";
+import {
+  Identifiable,
+  SmallIdentifiable,
+} from "../../../../../baseEntity/domains/identifiable/state";
+import {
+  BasicUpdater,
+  Updater,
+} from "../../../../../fun/domains/updater/state";
 import { BasicFun } from "../../../../../fun/state";
 import { Unit } from "../../../../../../main";
 export declare const OrderedMapRepo: {
-    Default: {
-        fromSmallIdentifiables: <T extends SmallIdentifiable>(array: T[]) => OrderedMap<T["id"], T>;
-        fromIdentifiables: <T extends Identifiable>(array: T[]) => OrderedMap<T["Id"], T>;
-    };
-    Updaters: {
-        replaceAndMerge<K, V>(key: K, originalMap: OrderedMap<K, V>, mergeMap: OrderedMap<K, V>): OrderedMap<K, V>;
-        filter<K, V>(predicate: BasicFun<[K, V], boolean>): Updater<OrderedMap<K, V>>;
-        set<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
-        insertAtBeginning<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
-        insertAtEnd<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
-        insertAt<K, V>([key, value]: [K, V], insertionPosition: K, order: "before" | "after"): Updater<OrderedMap<K, V>>;
-        remove<K, V>(key: K): Updater<OrderedMap<K, V>>;
-        clear<K, V>(): Updater<OrderedMap<K, V>>;
-        merge<K, V>(key: K, originalMap: OrderedMap<K, V>, mergeMap: OrderedMap<K, V>): OrderedMap<K, V>;
-        update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<OrderedMap<k, v>>;
-        upsert: <k, v>(k: k, defaultValue: BasicFun<Unit, v>, _: BasicUpdater<v>) => Updater<OrderedMap<k, v>>;
-        append: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
-        prepend: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
-    };
-    Operations: {
-        toArray: <T extends Identifiable>(map: OrderedMap<T["Id"], T>) => T[];
-    };
+  Default: {
+    fromSmallIdentifiables: <T extends SmallIdentifiable>(
+      array: T[],
+    ) => OrderedMap<T["id"], T>;
+    fromIdentifiables: <T extends Identifiable>(
+      array: T[],
+    ) => OrderedMap<T["Id"], T>;
+  };
+  Updaters: {
+    replaceAndMerge<K, V>(
+      key: K,
+      originalMap: OrderedMap<K, V>,
+      mergeMap: OrderedMap<K, V>,
+    ): OrderedMap<K, V>;
+    filter<K, V>(
+      predicate: BasicFun<[K, V], boolean>,
+    ): Updater<OrderedMap<K, V>>;
+    set<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
+    insertAtBeginning<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
+    insertAtEnd<K, V>(key: K, value: V): Updater<OrderedMap<K, V>>;
+    insertAt<K, V>(
+      [key, value]: [K, V],
+      insertionPosition: K,
+      order: "before" | "after",
+    ): Updater<OrderedMap<K, V>>;
+    remove<K, V>(key: K): Updater<OrderedMap<K, V>>;
+    clear<K, V>(): Updater<OrderedMap<K, V>>;
+    merge<K, V>(
+      key: K,
+      originalMap: OrderedMap<K, V>,
+      mergeMap: OrderedMap<K, V>,
+    ): OrderedMap<K, V>;
+    update: <k, v>(k: k, _: BasicUpdater<v>) => Updater<OrderedMap<k, v>>;
+    upsert: <k, v>(
+      k: k,
+      defaultValue: BasicFun<Unit, v>,
+      _: BasicUpdater<v>,
+    ) => Updater<OrderedMap<k, v>>;
+    append: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
+    prepend: <k, v>(newEntries: Array<[k, v]>) => Updater<OrderedMap<k, v>>;
+  };
+  Operations: {
+    toArray: <T extends Identifiable>(map: OrderedMap<T["Id"], T>) => T[];
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/collections/domains/valueOrErrors/state.d.ts

@@ -3,33 +3,59 @@ import { BasicFun, Fun } from "../../../fun/state";
 import { Value } from "../../../value/state";
 import { Errors } from "../errors/state";
 import { Unit, Option, Sum } from "../../../../main";
-export type ValueOrErrors<v, e> = ((Value<v> & {
-    kind: "value";
-}) | (Errors<e> & {
-    kind: "errors";
-})) & {
-    Map: <a, b, e>(this: ValueOrErrors<a, e>, f: BasicFun<a, b>) => ValueOrErrors<b, e>;
-    MapErrors: <a, e, e2>(this: ValueOrErrors<a, e>, f: BasicFun<List<e>, List<e2>>) => ValueOrErrors<a, e2>;
-    Flatten: <a, e>(this: ValueOrErrors<ValueOrErrors<a, e>, e>) => ValueOrErrors<a, e>;
-    Then: <a, b, e>(this: ValueOrErrors<a, e>, k: BasicFun<a, ValueOrErrors<b, e>>) => ValueOrErrors<b, e>;
+export type ValueOrErrors<v, e> = (
+  | (Value<v> & {
+      kind: "value";
+    })
+  | (Errors<e> & {
+      kind: "errors";
+    })
+) & {
+  Map: <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<a, b>,
+  ) => ValueOrErrors<b, e>;
+  MapErrors: <a, e, e2>(
+    this: ValueOrErrors<a, e>,
+    f: BasicFun<List<e>, List<e2>>,
+  ) => ValueOrErrors<a, e2>;
+  Flatten: <a, e>(
+    this: ValueOrErrors<ValueOrErrors<a, e>, e>,
+  ) => ValueOrErrors<a, e>;
+  Then: <a, b, e>(
+    this: ValueOrErrors<a, e>,
+    k: BasicFun<a, ValueOrErrors<b, e>>,
+  ) => ValueOrErrors<b, e>;
 };
 export declare const ValueOrErrors: {
-    Default: {
-        return: <v, e>(_: v) => ValueOrErrors<v, e>;
-        throwOne: <v, e>(_: e) => ValueOrErrors<v, e>;
-        throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
-        ofOption: <v, e>(v: Option<v>, e: BasicFun<Unit, e>) => ValueOrErrors<v, e>;
-    };
-    Operations: {
-        Return: <v, e>(_: v) => ValueOrErrors<v, e>;
-        Throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
-        Map: <a, b, e>(f: BasicFun<a, b>) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
-        MapErrors: <a, e, e2>(f: BasicFun<List<e>, List<e2>>) => BasicFun<ValueOrErrors<a, e>, ValueOrErrors<a, e2>>;
-        Flatten: <a, e>() => Fun<ValueOrErrors<ValueOrErrors<a, e>, e>, ValueOrErrors<a, e>>;
-        Then: <a, b, e>(k: BasicFun<a, ValueOrErrors<b, e>>) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
-        Catch: <v, e>(_: ValueOrErrors<v, e>) => ValueOrErrors<Sum<v, List<e>>, e>;
-        Fold: <v, e, c>(l: BasicFun<v, c>, r: BasicFun<List<e>, c>) => Fun<ValueOrErrors<v, e>, c>;
-        All: <v, e>(_: List<ValueOrErrors<v, e>>) => ValueOrErrors<List<v>, e>;
-    };
+  Default: {
+    return: <v, e>(_: v) => ValueOrErrors<v, e>;
+    throwOne: <v, e>(_: e) => ValueOrErrors<v, e>;
+    throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
+    ofOption: <v, e>(v: Option<v>, e: BasicFun<Unit, e>) => ValueOrErrors<v, e>;
+  };
+  Operations: {
+    Return: <v, e>(_: v) => ValueOrErrors<v, e>;
+    Throw: <v, e>(_: List<e>) => ValueOrErrors<v, e>;
+    Map: <a, b, e>(
+      f: BasicFun<a, b>,
+    ) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
+    MapErrors: <a, e, e2>(
+      f: BasicFun<List<e>, List<e2>>,
+    ) => BasicFun<ValueOrErrors<a, e>, ValueOrErrors<a, e2>>;
+    Flatten: <a, e>() => Fun<
+      ValueOrErrors<ValueOrErrors<a, e>, e>,
+      ValueOrErrors<a, e>
+    >;
+    Then: <a, b, e>(
+      k: BasicFun<a, ValueOrErrors<b, e>>,
+    ) => Fun<ValueOrErrors<a, e>, ValueOrErrors<b, e>>;
+    Catch: <v, e>(_: ValueOrErrors<v, e>) => ValueOrErrors<Sum<v, List<e>>, e>;
+    Fold: <v, e, c>(
+      l: BasicFun<v, c>,
+      r: BasicFun<List<e>, c>,
+    ) => Fun<ValueOrErrors<v, e>, c>;
+    All: <v, e>(_: List<ValueOrErrors<v, e>>) => ValueOrErrors<List<v>, e>;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/coroutines/builder.d.ts

@@ -3,68 +3,154 @@ import { Unit } from "../fun/domains/unit/state";
 import { BasicUpdater } from "../fun/domains/updater/state";
 import { BasicFun } from "../fun/state";
 import { Template } from "../template/state";
-import { Coroutine, InboundEventFromContext, InboundKindFromContext } from "./state";
+import {
+  Coroutine,
+  InboundEventFromContext,
+  InboundKindFromContext,
+} from "./state";
 import { CoroutineComponentOptions } from "./template";
 import { Guid } from "../baseEntity/domains/identifiable/state";
 import { SimpleCallback } from "../fun/domains/simpleCallback/state";
 export declare const CoTypedFactory: (<c, s>() => {
+  Seq: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
+  GetState: () => Coroutine<c & s, s, c & s>;
+  SetState: (stateUpdater: BasicUpdater<s>) => Coroutine<c & s, s, Unit>;
+  UpdateState: (
+    stateUpdater: BasicFun<s, BasicUpdater<s>>,
+  ) => Coroutine<c & s, s, Unit>;
+  Any: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
+  All: <result>(
+    ps: Array<Coroutine<c & s, s, result>>,
+  ) => Coroutine<c & s, s, result[]>;
+  Yield: (next: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
+  Wait: (ms: number) => Coroutine<c & s, s, Unit>;
+  Await: <r, err>(
+    p: BasicFun<Unit, Promise<r>>,
+    onErr: BasicFun<any, err>,
+    debugName?: string,
+  ) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
+  Repeat: (p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
+  Return: <r>(res: r) => Coroutine<c & s, s, r>;
+  While: (
+    predicate: BasicFun<[c & s], boolean>,
+    p: Coroutine<c & s, s, Unit>,
+  ) => Coroutine<c & s, s, Unit>;
+  For: <element>(
+    collection: Collection<number, element>,
+  ) => (
+    p: BasicFun<element, Coroutine<c & s, s, Unit>>,
+  ) => Coroutine<c & s, s, Unit>;
+  Embed: <parentContext, parentState, result>(
+    p: Coroutine<c & s, s, result>,
+    narrow: BasicFun<parentContext & parentState, c & s>,
+    widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>,
+  ) => Coroutine<parentContext & parentState, parentState, result>;
+  Template: <fm>(
+    initialCoroutine: Coroutine<c & s, s, Unit>,
+    options?: CoroutineComponentOptions<c & s, s>,
+  ) => Template<c & s, s, fm>;
+  Trigger: <
+    event extends {
+      id: Guid;
+      kind: kind;
+    },
+    kind extends string,
+  >(
+    event: event,
+  ) => Coroutine<
+    c &
+      s & {
+        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
+      },
+    s & {
+      outboundEvents: Map<kind, OrderedMap<Guid, event>>;
+    },
+    Unit
+  >;
+  Do: (action: SimpleCallback<void>) => Coroutine<c & s, s, Unit>;
+}) & {
+  withOn: <
+    eventKind,
+    event,
+    c,
+    s extends {
+      inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
+    },
+  >() => {
+    On: <matchedEvent extends InboundKindFromContext<c & s>>(
+      kind: matchedEvent,
+      filter?: BasicFun<
+        [
+          InboundEventFromContext<c & s> & {
+            kind: matchedEvent;
+          },
+          c & s,
+        ],
+        boolean
+      >,
+    ) => Coroutine<
+      c & s,
+      s,
+      InboundEventFromContext<c & s> & {
+        kind: matchedEvent;
+      }
+    >;
     Seq: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
     GetState: () => Coroutine<c & s, s, c & s>;
     SetState: (stateUpdater: BasicUpdater<s>) => Coroutine<c & s, s, Unit>;
-    UpdateState: (stateUpdater: BasicFun<s, BasicUpdater<s>>) => Coroutine<c & s, s, Unit>;
+    UpdateState: (
+      stateUpdater: BasicFun<s, BasicUpdater<s>>,
+    ) => Coroutine<c & s, s, Unit>;
     Any: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
-    All: <result>(ps: Array<Coroutine<c & s, s, result>>) => Coroutine<c & s, s, result[]>;
+    All: <result>(
+      ps: Coroutine<c & s, s, result>[],
+    ) => Coroutine<c & s, s, result[]>;
     Yield: (next: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
     Wait: (ms: number) => Coroutine<c & s, s, Unit>;
-    Await: <r, err>(p: BasicFun<Unit, Promise<r>>, onErr: BasicFun<any, err>, debugName?: string) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
+    Await: <r, err>(
+      p: BasicFun<Unit, Promise<r>>,
+      onErr: BasicFun<any, err>,
+      debugName?: string,
+    ) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
     Repeat: (p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
     Return: <r>(res: r) => Coroutine<c & s, s, r>;
-    While: (predicate: BasicFun<[c & s], boolean>, p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-    For: <element>(collection: Collection<number, element>) => (p: BasicFun<element, Coroutine<c & s, s, Unit>>) => Coroutine<c & s, s, Unit>;
-    Embed: <parentContext, parentState, result>(p: Coroutine<c & s, s, result>, narrow: BasicFun<parentContext & parentState, c & s>, widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>) => Coroutine<parentContext & parentState, parentState, result>;
-    Template: <fm>(initialCoroutine: Coroutine<c & s, s, Unit>, options?: CoroutineComponentOptions<c & s, s>) => Template<c & s, s, fm>;
-    Trigger: <event extends {
+    While: (
+      predicate: BasicFun<[c & s], boolean>,
+      p: Coroutine<c & s, s, Unit>,
+    ) => Coroutine<c & s, s, Unit>;
+    For: <element>(
+      collection: Collection<number, element>,
+    ) => (
+      p: BasicFun<element, Coroutine<c & s, s, Unit>>,
+    ) => Coroutine<c & s, s, Unit>;
+    Embed: <parentContext, parentState, result>(
+      p: Coroutine<c & s, s, result>,
+      narrow: BasicFun<parentContext & parentState, c & s>,
+      widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>,
+    ) => Coroutine<parentContext & parentState, parentState, result>;
+    Template: <fm>(
+      initialCoroutine: Coroutine<c & s, s, Unit>,
+      options?: CoroutineComponentOptions<c & s, s> | undefined,
+    ) => Template<c & s, s, fm>;
+    Trigger: <
+      event_1 extends {
         id: Guid;
         kind: kind;
-    }, kind extends string>(event: event) => Coroutine<c & s & {
-        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
-    }, s & {
-        outboundEvents: Map<kind, OrderedMap<Guid, event>>;
-    }, Unit>;
+      },
+      kind extends string,
+    >(
+      event: event_1,
+    ) => Coroutine<
+      c &
+        s & {
+          outboundEvents: Map<kind, OrderedMap<string, event_1>>;
+        },
+      s & {
+        outboundEvents: Map<kind, OrderedMap<string, event_1>>;
+      },
+      Unit
+    >;
     Do: (action: SimpleCallback<void>) => Coroutine<c & s, s, Unit>;
-}) & {
-    withOn: <eventKind, event, c, s extends {
-        inboundEvents: Map<eventKind, OrderedMap<Guid, event>>;
-    }>() => {
-        On: <matchedEvent extends InboundKindFromContext<c & s>>(kind: matchedEvent, filter?: BasicFun<[InboundEventFromContext<c & s> & {
-            kind: matchedEvent;
-        }, c & s], boolean>) => Coroutine<c & s, s, InboundEventFromContext<c & s> & {
-            kind: matchedEvent;
-        }>;
-        Seq: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
-        GetState: () => Coroutine<c & s, s, c & s>;
-        SetState: (stateUpdater: BasicUpdater<s>) => Coroutine<c & s, s, Unit>;
-        UpdateState: (stateUpdater: BasicFun<s, BasicUpdater<s>>) => Coroutine<c & s, s, Unit>;
-        Any: (ps: Coroutine<c & s, s, Unit>[]) => Coroutine<c & s, s, Unit>;
-        All: <result>(ps: Coroutine<c & s, s, result>[]) => Coroutine<c & s, s, result[]>;
-        Yield: (next: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-        Wait: (ms: number) => Coroutine<c & s, s, Unit>;
-        Await: <r, err>(p: BasicFun<Unit, Promise<r>>, onErr: BasicFun<any, err>, debugName?: string) => Coroutine<c & s, s, import("../../main").Sum<r, err>>;
-        Repeat: (p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-        Return: <r>(res: r) => Coroutine<c & s, s, r>;
-        While: (predicate: BasicFun<[c & s], boolean>, p: Coroutine<c & s, s, Unit>) => Coroutine<c & s, s, Unit>;
-        For: <element>(collection: Collection<number, element>) => (p: BasicFun<element, Coroutine<c & s, s, Unit>>) => Coroutine<c & s, s, Unit>;
-        Embed: <parentContext, parentState, result>(p: Coroutine<c & s, s, result>, narrow: BasicFun<parentContext & parentState, c & s>, widen: BasicFun<BasicUpdater<s>, BasicUpdater<parentState>>) => Coroutine<parentContext & parentState, parentState, result>;
-        Template: <fm>(initialCoroutine: Coroutine<c & s, s, Unit>, options?: CoroutineComponentOptions<c & s, s> | undefined) => Template<c & s, s, fm>;
-        Trigger: <event_1 extends {
-            id: Guid;
-            kind: kind;
-        }, kind extends string>(event: event_1) => Coroutine<c & s & {
-            outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-        }, s & {
-            outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-        }, Unit>;
-        Do: (action: SimpleCallback<void>) => Coroutine<c & s, s, Unit>;
-    };
+  };
 };
-//# sourceMappingURL=builder.d.ts.map
+//# sourceMappingURL=builder.d.ts.map