ballerina-core 1.0.220 → 1.0.222

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/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

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

@@ -1,5 +1,13 @@
 import { InfiniteStreamWritableState } from "../state";
-export declare const StreamDataLoader: <Element extends {
+export declare const StreamDataLoader: <
+  Element extends {
     Id: string;
-}, foreignMutations>() => import("../../template/state").Template<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, foreignMutations, import("../../../main").Unit>;
-//# sourceMappingURL=runner.d.ts.map
+  },
+  foreignMutations,
+>() => import("../../template/state").Template<
+  InfiniteStreamWritableState<Element>,
+  InfiniteStreamWritableState<Element>,
+  foreignMutations,
+  import("../../../main").Unit
+>;
+//# sourceMappingURL=runner.d.ts.map

package/bin/src/infinite-data-stream/template.d.ts

@@ -1,7 +1,14 @@
 import { Unit } from "../fun/domains/unit/state";
 import { Template } from "../template/state";
 import { InfiniteStreamWritableState } from "./state";
-export declare const InfiniteStreamTemplate: <Element extends {
+export declare const InfiniteStreamTemplate: <
+  Element extends {
     Id: string;
-}>() => Template<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, Unit, Unit>;
-//# sourceMappingURL=template.d.ts.map
+  },
+>() => Template<
+  InfiniteStreamWritableState<Element>,
+  InfiniteStreamWritableState<Element>,
+  Unit,
+  Unit
+>;
+//# sourceMappingURL=template.d.ts.map

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

@@ -2,10 +2,26 @@ import { OrderedMap } from "immutable";
 import { Guid, Unit, SynchronizationResult } from "../../main";
 import { Coroutine } from "../coroutines/state";
 import { BasicFun } from "../fun/state";
-export declare const QueueCoroutine: <Context, State, OperationResult = SynchronizationResult>(removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>, getItemsToProcess: BasicFun<Context & State, OrderedMap<Guid, {
-    preprocess: Coroutine<Context & State, State, Unit>;
-    operation: Coroutine<Context & State, State, OperationResult>;
-    postprocess: BasicFun<OperationResult, Coroutine<Context & State, State, Unit>>;
-    reenqueue: Coroutine<Context & State, State, Unit>;
-}>>) => Coroutine<Context & State, State, Unit>;
-//# sourceMappingURL=state.d.ts.map
+export declare const QueueCoroutine: <
+  Context,
+  State,
+  OperationResult = SynchronizationResult,
+>(
+  removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>,
+  getItemsToProcess: BasicFun<
+    Context & State,
+    OrderedMap<
+      Guid,
+      {
+        preprocess: Coroutine<Context & State, State, Unit>;
+        operation: Coroutine<Context & State, State, OperationResult>;
+        postprocess: BasicFun<
+          OperationResult,
+          Coroutine<Context & State, State, Unit>
+        >;
+        reenqueue: Coroutine<Context & State, State, Unit>;
+      }
+    >
+  >,
+) => Coroutine<Context & State, State, Unit>;
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,60 +1,168 @@
 import { BasicFun } from "../fun/state";
 import { BasicUpdater } from "../fun/domains/updater/state";
 import { Unit } from "../../main";
-export type View<context, state, foreignMutations, embeddedChildren = Unit> = (props: HeadlessTemplateProps<context, state, foreignMutations> & embeddedChildren) => JSX.Element;
+export type View<context, state, foreignMutations, embeddedChildren = Unit> = (
+  props: HeadlessTemplateProps<context, state, foreignMutations> &
+    embeddedChildren,
+) => JSX.Element;
 export type HeadlessTemplateProps<context, state, foreignMutations> = {
-    context: context;
-    setState: BasicFun<BasicUpdater<state>, void>;
-    foreignMutations: foreignMutations;
+  context: context;
+  setState: BasicFun<BasicUpdater<state>, void>;
+  foreignMutations: foreignMutations;
 };
 export type TemplateChildren = JSX.Element | JSX.Element[];
-export type Wrapper = BasicFun<{
+export type Wrapper = BasicFun<
+  {
     children?: TemplateChildren;
-}, JSX.Element>;
+  },
+  JSX.Element
+>;
 export type TemplateProps<context, state, foreignMutations, view = Unit> = {
-    context: context;
-    setState: BasicFun<BasicUpdater<state>, void>;
-    foreignMutations: foreignMutations;
-    view: view;
-    children?: TemplateChildren;
+  context: context;
+  setState: BasicFun<BasicUpdater<state>, void>;
+  foreignMutations: foreignMutations;
+  view: view;
+  children?: TemplateChildren;
 };
-type TemplateRunner<context, state, foreignMutations, view = Unit> = (props: TemplateProps<context, state, foreignMutations, view>) => JSX.Element;
+type TemplateRunner<context, state, foreignMutations, view = Unit> = (
+  props: TemplateProps<context, state, foreignMutations, view>,
+) => JSX.Element;
 export type Template<context, state, foreignMutations, view = Unit> = {
-    any: BasicFun<Array<Template<context, state, foreignMutations>>, Template<context, state, foreignMutations, view>>;
-    wrap: (Wrapper: Wrapper) => Template<context, state, foreignMutations, view>;
-    withView: (view: view) => Template<context, state, foreignMutations, Unit>;
-    withViewFromProps: (f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>) => Template<context, state, foreignMutations, Unit>;
-    mapState: <newState>(f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
-    mapStateFromProps: <newState>(f: BasicFun<[
+  any: BasicFun<
+    Array<Template<context, state, foreignMutations>>,
+    Template<context, state, foreignMutations, view>
+  >;
+  wrap: (Wrapper: Wrapper) => Template<context, state, foreignMutations, view>;
+  withView: (view: view) => Template<context, state, foreignMutations, Unit>;
+  withViewFromProps: (
+    f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>,
+  ) => Template<context, state, foreignMutations, Unit>;
+  mapState: <newState>(
+    f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>,
+  ) => Template<context, newState, foreignMutations, view>;
+  mapStateFromProps: <newState>(
+    f: BasicFun<
+      [
         TemplateProps<context, newState, foreignMutations, view>,
-        BasicUpdater<state>
-    ], BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
-    mapContext: <newContext>(f: BasicFun<newContext, context | undefined>) => Template<newContext, state, foreignMutations, view>;
-    mapForeignMutations: <newForeignMutations>(f: BasicFun<newForeignMutations, foreignMutations>) => Template<context, state, newForeignMutations, view>;
-    mapContextFromProps: <newContext>(f: BasicFun<TemplateProps<newContext, state, foreignMutations, view>, context | undefined>) => Template<newContext, state, foreignMutations, view>;
-    mapForeignMutationsFromProps: <newForeignMutations>(f: BasicFun<TemplateProps<context, state, newForeignMutations, view>, foreignMutations>) => Template<context, state, newForeignMutations, view>;
-    mapView: <newView>(f: BasicFun<newView, view>) => Template<context, state, foreignMutations, newView>;
-    mapViewFromProps: <newView>(f: BasicFun<TemplateProps<context, state, foreignMutations, newView>, view>) => Template<context, state, foreignMutations, newView>;
+        BasicUpdater<state>,
+      ],
+      BasicUpdater<newState>
+    >,
+  ) => Template<context, newState, foreignMutations, view>;
+  mapContext: <newContext>(
+    f: BasicFun<newContext, context | undefined>,
+  ) => Template<newContext, state, foreignMutations, view>;
+  mapForeignMutations: <newForeignMutations>(
+    f: BasicFun<newForeignMutations, foreignMutations>,
+  ) => Template<context, state, newForeignMutations, view>;
+  mapContextFromProps: <newContext>(
+    f: BasicFun<
+      TemplateProps<newContext, state, foreignMutations, view>,
+      context | undefined
+    >,
+  ) => Template<newContext, state, foreignMutations, view>;
+  mapForeignMutationsFromProps: <newForeignMutations>(
+    f: BasicFun<
+      TemplateProps<context, state, newForeignMutations, view>,
+      foreignMutations
+    >,
+  ) => Template<context, state, newForeignMutations, view>;
+  mapView: <newView>(
+    f: BasicFun<newView, view>,
+  ) => Template<context, state, foreignMutations, newView>;
+  mapViewFromProps: <newView>(
+    f: BasicFun<TemplateProps<context, state, foreignMutations, newView>, view>,
+  ) => Template<context, state, foreignMutations, newView>;
 } & TemplateRunner<context, state, foreignMutations, view>;
-export declare const createTemplate: <context, state, foreignMutations, view>(actual: TemplateRunner<context, state, foreignMutations, view>) => Template<context, state, foreignMutations, view>;
+export declare const createTemplate: <context, state, foreignMutations, view>(
+  actual: TemplateRunner<context, state, foreignMutations, view>,
+) => Template<context, state, foreignMutations, view>;
 export declare const Template: {
-    Default: <context, state, foreignMutations, view = Unit>(actual: TemplateRunner<context & state, state, foreignMutations, view>) => Template<context & state, state, foreignMutations, view>;
-    Operations: {
-        Wrap: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, Wrapper: BasicFun<{
-            children?: TemplateChildren;
-        }, JSX.Element>) => Template<context, state, foreignMutations, view>;
-        WithView: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, view: view) => Template<context, state, foreignMutations, Unit>;
-        WithViewFromProps: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>) => Template<context, state, foreignMutations, Unit>;
-        MapState: <context, state, newState, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
-        MapStateFromProps: <context, state, newState, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<[TemplateProps<context, newState, foreignMutations, view>, BasicUpdater<state>], BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
-        MapContext: <context, newContext, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<newContext, context | undefined>) => Template<newContext, state, foreignMutations, view>;
-        MapForeignMutations: <context, state, foreignMutations, newForeignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<newForeignMutations, foreignMutations>) => Template<context, state, newForeignMutations, view>;
-        MapContextFromProps: <context, newContext, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<newContext, state, foreignMutations, view>, context | undefined>) => Template<newContext, state, foreignMutations, view>;
-        MapForeignMutationsFromProps: <context, state, foreignMutations, newForeignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<context, state, newForeignMutations, view>, foreignMutations>) => Template<context, state, newForeignMutations, view>;
-        Any: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, others: Array<Template<context, state, foreignMutations>>) => Template<context, state, foreignMutations, view>;
-        MapView: <context, state, foreignMutations, newView, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<newView, view>) => Template<context, state, foreignMutations, newView>;
-        MapViewFromProps: <context, state, foreignMutations, newView, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<context, state, foreignMutations, newView>, view>) => Template<context, state, foreignMutations, newView>;
-    };
+  Default: <context, state, foreignMutations, view = Unit>(
+    actual: TemplateRunner<context & state, state, foreignMutations, view>,
+  ) => Template<context & state, state, foreignMutations, view>;
+  Operations: {
+    Wrap: <context, state, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      Wrapper: BasicFun<
+        {
+          children?: TemplateChildren;
+        },
+        JSX.Element
+      >,
+    ) => Template<context, state, foreignMutations, view>;
+    WithView: <context, state, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      view: view,
+    ) => Template<context, state, foreignMutations, Unit>;
+    WithViewFromProps: <context, state, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>,
+    ) => Template<context, state, foreignMutations, Unit>;
+    MapState: <context, state, newState, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>,
+    ) => Template<context, newState, foreignMutations, view>;
+    MapStateFromProps: <context, state, newState, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<
+        [
+          TemplateProps<context, newState, foreignMutations, view>,
+          BasicUpdater<state>,
+        ],
+        BasicUpdater<newState>
+      >,
+    ) => Template<context, newState, foreignMutations, view>;
+    MapContext: <context, newContext, state, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<newContext, context | undefined>,
+    ) => Template<newContext, state, foreignMutations, view>;
+    MapForeignMutations: <
+      context,
+      state,
+      foreignMutations,
+      newForeignMutations,
+      view,
+    >(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<newForeignMutations, foreignMutations>,
+    ) => Template<context, state, newForeignMutations, view>;
+    MapContextFromProps: <context, newContext, state, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<
+        TemplateProps<newContext, state, foreignMutations, view>,
+        context | undefined
+      >,
+    ) => Template<newContext, state, foreignMutations, view>;
+    MapForeignMutationsFromProps: <
+      context,
+      state,
+      foreignMutations,
+      newForeignMutations,
+      view,
+    >(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<
+        TemplateProps<context, state, newForeignMutations, view>,
+        foreignMutations
+      >,
+    ) => Template<context, state, newForeignMutations, view>;
+    Any: <context, state, foreignMutations, view>(
+      p: Template<context, state, foreignMutations, view>,
+      others: Array<Template<context, state, foreignMutations>>,
+    ) => Template<context, state, foreignMutations, view>;
+    MapView: <context, state, foreignMutations, newView, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<newView, view>,
+    ) => Template<context, state, foreignMutations, newView>;
+    MapViewFromProps: <context, state, foreignMutations, newView, view>(
+      p: Template<context, state, foreignMutations, view>,
+      f: BasicFun<
+        TemplateProps<context, state, foreignMutations, newView>,
+        view
+      >,
+    ) => Template<context, state, foreignMutations, newView>;
+  };
 };
 export {};
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,10 +1,24 @@
 import { BasicFun, Unit, Option } from "../../main";
-export type ValidationResult = "valid" | {
-    kind: "error";
-    errors: Array<string>;
-};
-export type TypeDescriptor<T> = T extends Date ? "date" : T extends number ? "number" : T extends boolean ? "boolean" : T extends string ? "string" : T extends Unit ? {} & {
-    [_ in keyof T]: TypeDescriptor<T[_]>;
-} : never;
-export declare const parse: <E>(entityDescriptor: TypeDescriptor<E>) => BasicFun<any, Option<E>>;
-//# sourceMappingURL=state.d.ts.map
+export type ValidationResult =
+  | "valid"
+  | {
+      kind: "error";
+      errors: Array<string>;
+    };
+export type TypeDescriptor<T> = T extends Date
+  ? "date"
+  : T extends number
+    ? "number"
+    : T extends boolean
+      ? "boolean"
+      : T extends string
+        ? "string"
+        : T extends Unit
+          ? {} & {
+              [_ in keyof T]: TypeDescriptor<T[_]>;
+            }
+          : never;
+export declare const parse: <E>(
+  entityDescriptor: TypeDescriptor<E>,
+) => BasicFun<any, Option<E>>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/value/domains/mutable-value/state.d.ts

@@ -1,9 +1,9 @@
 import { SimpleCallback } from "ballerina-core";
 import { Value } from "../../state";
 export type MutableValue<v> = Value<v> & {
-    onChange: SimpleCallback<v>;
+  onChange: SimpleCallback<v>;
 };
 export declare const MutableValue: {
-    Default: <v>(v: v, onChange: SimpleCallback<v>) => MutableValue<v>;
+  Default: <v>(v: v, onChange: SimpleCallback<v>) => MutableValue<v>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map