ballerina-core 1.0.219 → 1.0.220

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

@@ -1,34 +1,9 @@
 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,23 +4,19 @@ 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,38 +1,24 @@
 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,58 +1,30 @@
 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,59 +3,33 @@ 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,154 +3,68 @@ 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: Coroutine<c & s, s, result>[],
-    ) => Coroutine<c & s, s, result[]>;
+    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>>;
+    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 {
+    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_1,
-    ) => Coroutine<
-      c &
-        s & {
-          outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-        },
-      s & {
-        outboundEvents: Map<kind, OrderedMap<string, event_1>>;
-      },
-      Unit
-    >;
+    }, 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>;
+        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